Logic eval error: invalid Box reference

[Aro1914]

I'm making a remote API call, that accesses two boxes in its consensus block

Below are the relevant parts of both contracts that are directly related to the issue at hand

// Some types
const userObj = Object({
	address: Address,
	decision: Bool,
})

const evaluationParams = Struct([
	['proposer', Address],
	['user_1', userObj],
	['user_2', userObj],
])

// This is how the API call is set up in the oracle contract:
const Client = API('Client', {
	evaluate: Fun([evaluationParams], Bool),
})

// ... Some code in-between

// This is how the map is set up in the oracle contract:
const usersMap = new Map(Address, userObject)

// ... Some code in-between

// Parallel reduce setup
// Here is the API block
	         .api_(Client.evaluate, (evaluatingParams) => {
			const paramsStruct = evaluationParams.fromObject(evaluatingParams)
			const paramsObject = evaluationParams.toObject(paramsStruct)
			const { proposer, user_1, user_2 } = paramsObject
			check(usersSet.member(proposer), 'The proposer has no account')
			check(usersSet.member(user_1.address), 'User 1 has no account')
			check(usersSet.member(user_2.address), 'User 2 has no account')
			return [
				[0, [0, token]],
				(ret) => {
					const agreed = user_1.decision && user_2.decision
					if (agreed) {
						const { vault: vault_1, ...user_1sDetails } = fromUsersMap(
							usersMap[user_1.address]
						)
						const { vault: vault_2, ...user_2sDetails } = fromUsersMap(
							usersMap[user_2.address]
						)
						const due = vault_1 + vault_2
						if (heldToken >= due) transfer(due, token).to(proposer)
						usersMap[user_1.address] = {
							...user_1sDetails,
							vault: 0,
						}
						usersMap[user_2.address] = {
							...user_2sDetails,
							vault: 0,
						}
						ret(agreed)
						return [heldToken - due]
					} else {
						ret(agreed)
						return [heldToken]
					}
				},
			]
		})

Then in the contract making the remote call, I have it set up like so:

const externalStructure = {
	Client_evaluate: Fun([evaluationParams], Bool),
}

const externalCalls = remote(mainContract, externalStructure)

// ... Some code in-between

	const evaluatingParams = {
		proposer: D,
		user_1: {
			address: user_1,
			decision: user_1Response, // A boolean looping variable from a parallelReduce
		},
		user_2: {
			address: user_2,
			decision: user_2Response, // A boolean looping variable from a parallelReduce
		},
	}

        const evaluationResult = externalCalls.Client_evaluate.ALGO({
                fees: 1,
                assets: [token],
		accounts: [D, user_1, user_2], // user_1 and user_2 are of type Address and are brought in through the interact interface of participant D
		boxes: [
			[mainContract, 0, user_1], // mainContract is of type Contract and like user_1 and user_2 is brought in through the interact interface of participant D
			[mainContract, 0, user_2],
		],
        })(evaluationParams.fromObject(evaluatingParams))

But when I test run the application and it gets to this stage in the client contract, I keep getting an error similar to this:

I say similar, because this error was generated from a similar remote call from one of my contracts. I do not have the screenshot of this particular communication at the time of writing this.

Please I'd like to know exactly how to discern the Map index and what should be provided as the Map key of a Map that uses Addresses as Keys.

[jeapostrophe]

You are providing the map index of 0, but it looks like it is actually 1. The map index is the order it appears in the program. So the first one is 0 and the second is 1 and so on.

[Aro1914]

I've seen this warning before, it actually prevents the test suite from proceeding during runtime

[Aro1914]

It works!!

[Aro1914]

Thank you so much Jay, for helping me out with this.

[jeapostrophe]

I'm glad it works!!

[Aro1914]

I'm most grateful

[Aro1914]

As Jay mentioned, when providing the boxes for the remote call, you also have to take into consideration any Set that was referenced within the remote call.

In my case I had used a Set and a Map within my API block, 3 checks to confirm the identify of the Addresses supplied to the call, and 2 Map References.

In the remote call I was expected to provide the boxes for both the Set referenced and the Map, as Sets are actually Maps too. But I was toggling between indexes 0 and 1 in a bit to resolve it through trial and error, without any real understanding as to how the indexes are derived.

Thanks to Jay, I have come to understand the right way to supply the boxes needed for a remote call.

First discern how many boxes were referenced, be it a Set that was only used to check if a particular address is a member, or a simple property lookup in a Map. Then take note of the order these Sets and Maps were defined in the oracle contract, and not how they were referenced within the call.

For the first Map or Set defined in the oracle contract, that would have an index of 0, the next 1, and the following one to that, 2, and so, in incrementing order (remember both Sets and Maps are Maps, so both share this same indexing order of definition).

Then also take note of the keys used for referencing these Sets or Maps within the remote call, these would serve as the key of the box.

Now after noting all that is necessary... You pass in the information to the REMOTE_FUN.ALGO opts object:

REMOTE_FUN.ALGO({
    fees: IntegerValue,
    assets: [TokenValue, ...Any other referenced tokens],
    accounts: [AddressValue, ...Any other referenced account],
    boxes: [[ContractValue, Map Index, Map Key], ...Any other referenced box]
})(...args)

Here's an example of such a call:

remoteFuncs.Foo_Bar.ALGO({
    fees: 1,
    assets: [token],
    accounts: [D, user_1, user_2],
    boxes: [
        [mainContract, 0, D],
        [mainContract, 1, user_1],
        [mainContract, 1, user_2],
    ],
})(D, user_1, user_2)

In this example, a fixed fee amount is provided, in case the calculated fee exceeds that of the flat fee.

Assets was provided because in my consensus block I made a transfer of that token.

In the above example, 3 accounts were passed to the remote call, as these 3 accounts would be referenced within the remote call.

Then 3 boxes are provided, the first being the participant, D, the second for user_1 and third for, user_2.

The Set used as a reference for the first account, D, is defined as the first implicit Map in the oracle contract, therefore has an index of 0 being the first to be declared.

Next, the other accounts, user_1 and user_2, were used to reference the second Map defined in the oracle contract, hence the index of 1 being passed.

With a setup such as this, it is important to note:

• Not many accounts can be provided on a remote call.
• Not many boxes can be provided for a remote call.
• Reduce as much as possible, the amount of accounts used in a function that may be called remotely.
• Instead of using too many Set references to validate an address' identity, if the consensus block also references a Map and the address ought to be shared between the Set and the Map... Then use:

check(isSome(map[address]), 'Not a member')

Instead of

check(set.member(address), 'Not a member')

As this would save you the amount of boxes you would need to provide the boxes opt field of the .ALGO remote extension, and by extension keep you within the transaction reference limit.

This is because, the Application step with the remote call may end up using more transaction references than the limit allows if not properly managed.

I hope this makes your next use of remote functions easier.

Terms Explained:
Oracle Contract - This is contract from which a remote function is being called.
Remote Call - This is a function within an external contract that is being called by another contract.