From 632b14cf80bf87dc97cf2016c6d7a0a3a8a909e2 Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Wed, 19 Jun 2024 10:25:01 -0400 Subject: [PATCH 1/9] chore: add contract to repo --- reference_contract/AlgoDID.approval.teal | 655 +++++++++++++++++++++++ reference_contract/AlgoDID.arc32.json | 223 ++++++++ reference_contract/AlgoDID.arc4.json | 143 +++++ reference_contract/README.md | 7 + reference_contract/algo-did.algo.ts | 180 +++++++ 5 files changed, 1208 insertions(+) create mode 100644 reference_contract/AlgoDID.approval.teal create mode 100644 reference_contract/AlgoDID.arc32.json create mode 100644 reference_contract/AlgoDID.arc4.json create mode 100644 reference_contract/README.md create mode 100644 reference_contract/algo-did.algo.ts diff --git a/reference_contract/AlgoDID.approval.teal b/reference_contract/AlgoDID.approval.teal new file mode 100644 index 0000000..69107f4 --- /dev/null +++ b/reference_contract/AlgoDID.approval.teal @@ -0,0 +1,655 @@ +#pragma version 9 + +// This TEAL was generated by TEALScript v0.51.1 +// https://github.com/algorand-devrel/TEALScript + +// This contract is compliant with and/or implements the following ARCs: [ ARC4 ] + +// The following ten lines of TEAL handle initial program flow +// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed +// Here, action refers to the OnComplete in combination with whether the app is being created or called +// Every possible action for this contract is represented in the switch statement +// If the action is not implmented in the contract, its repsective branch will be "NOT_IMPLMENTED" which just contains "err" +txn ApplicationID +int 0 +> +int 6 +* +txn OnCompletion ++ +switch create_NoOp NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED call_NoOp NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED call_UpdateApplication + +NOT_IMPLEMENTED: + err + +// startUpload(pay,uint64,uint64,address)void +// +// +// Allocate boxes to begin data upload process +// +// @param pubKey The pubkey of the DID +// @param numBoxes The number of boxes that the data will take up +// @param endBoxSize The size of the last box +// @param mbrPayment Payment from the uploader to cover the box MBR +abi_route_startUpload: + byte 0x; dupn 3 // push empty bytes to fill the stack frame for this subroutine's local variables + + // mbrPayment: pay + txn GroupIndex + int 1 + - + dup + gtxns TypeEnum + int pay + == + assert + + // endBoxSize: uint64 + txna ApplicationArgs 3 + btoi + + // numBoxes: uint64 + txna ApplicationArgs 2 + btoi + + // pubKey: address + txna ApplicationArgs 1 + dup + len + int 32 + == + assert + + // execute startUpload(pay,uint64,uint64,address)void + callsub startUpload + int 1 + return + +startUpload: + proto 8 0 + + // contracts/algo-did.algo.ts:64 + // assert(this.txn.sender === globals.creatorAddress) + txn Sender + global CreatorAddress + == + assert + + // contracts/algo-did.algo.ts:66 + // startBox = this.currentIndex.value + byte 0x63757272656e74496e646578 // "currentIndex" + app_global_get + frame_bury -5 // startBox: uint64 + + // contracts/algo-did.algo.ts:67 + // endBox = startBox + numBoxes - 1 + frame_dig -5 // startBox: uint64 + frame_dig -2 // numBoxes: uint64 + + + int 1 + - + frame_bury -6 // endBox: uint64 + + // contracts/algo-did.algo.ts:69 + // metadata: Metadata = { + // start: startBox, end: endBox, status: UPLOADING, endSize: endBoxSize, lastDeleted: 0, + // } + frame_dig -5 // startBox: uint64 + itob + frame_dig -6 // endBox: uint64 + itob + concat + byte 0x00 + byte 0x00 + bitlen + int 8 + <= + assert + byte 0xFF + b& + concat + frame_dig -3 // endBoxSize: uint64 + itob + concat + byte 0x0000000000000000 + concat + frame_bury -7 // metadata: Metadata + + // contracts/algo-did.algo.ts:73 + // assert(!this.metadata(pubKey).exists) + frame_dig -1 // pubKey: address + box_len + swap + pop + ! + assert + + // contracts/algo-did.algo.ts:75 + // this.metadata(pubKey).value = metadata + frame_dig -1 // pubKey: address + frame_dig -7 // metadata: Metadata + box_put + + // contracts/algo-did.algo.ts:77 + // this.currentIndex.value = endBox + 1 + byte 0x63757272656e74496e646578 // "currentIndex" + frame_dig -6 // endBox: uint64 + int 1 + + + app_global_put + + // contracts/algo-did.algo.ts:79 + // totalCost = numBoxes * COST_PER_BOX // cost of data boxes + // + (numBoxes - 1) * MAX_BOX_SIZE * COST_PER_BYTE // cost of data + // + numBoxes * 8 * COST_PER_BYTE // cost of data keys + // + endBoxSize * COST_PER_BYTE // cost of last data box + // + COST_PER_BOX + (8 + 8 + 1 + 8 + 32 + 8) * COST_PER_BYTE + frame_dig -2 // numBoxes: uint64 + int 2500 + * + frame_dig -2 // numBoxes: uint64 + int 1 + - + int 32768 + * + int 400 + * + + + frame_dig -2 // numBoxes: uint64 + int 8 + * + int 400 + * + + + frame_dig -3 // endBoxSize: uint64 + int 400 + * + + + int 2500 + + + int 26000 + + + frame_bury -8 // totalCost: uint64 + + // contracts/algo-did.algo.ts:85 + // assert(mbrPayment.amount === totalCost) + frame_dig -4 // mbrPayment: pay + gtxns Amount + frame_dig -8 // totalCost: uint64 + == + assert + + // contracts/algo-did.algo.ts:86 + // assert(mbrPayment.receiver === this.app.address) + frame_dig -4 // mbrPayment: pay + gtxns Receiver + global CurrentApplicationAddress + == + assert + retsub + +// upload(bytes,uint64,uint64,address)void +// +// +// Upload data to a specific offset in a box +// +// @param pubKey The pubkey of the DID +// @param boxIndex The index of the box to upload the given chunk of data to +// @param offset The offset within the box to start writing the data +// @param data The data to write +abi_route_upload: + byte 0x // push empty bytes to fill the stack frame for this subroutine's local variables + + // data: byte[] + txna ApplicationArgs 4 + extract 2 0 + + // offset: uint64 + txna ApplicationArgs 3 + btoi + + // boxIndex: uint64 + txna ApplicationArgs 2 + btoi + + // pubKey: address + txna ApplicationArgs 1 + dup + len + int 32 + == + assert + + // execute upload(bytes,uint64,uint64,address)void + callsub upload + int 1 + return + +upload: + proto 5 0 + + // contracts/algo-did.algo.ts:99 + // assert(this.txn.sender === globals.creatorAddress) + txn Sender + global CreatorAddress + == + assert + + // contracts/algo-did.algo.ts:101 + // metadata = this.metadata(pubKey).value + frame_dig -1 // pubKey: address + frame_bury -5 // storage key//metadata + + // contracts/algo-did.algo.ts:102 + // assert(metadata.status === UPLOADING) + frame_dig -5 // storage key//metadata + box_get + assert + extract 16 1 + byte 0x0000000000000000 + b== + assert + + // contracts/algo-did.algo.ts:103 + // assert(metadata.start <= boxIndex && boxIndex <= metadata.end) + frame_dig -5 // storage key//metadata + box_get + assert + extract 0 8 + btoi + frame_dig -2 // boxIndex: uint64 + <= + dup + bz skip_and0 + frame_dig -2 // boxIndex: uint64 + frame_dig -5 // storage key//metadata + box_get + assert + extract 8 8 + btoi + <= + && + +skip_and0: + assert + + // if0_condition + // contracts/algo-did.algo.ts:105 + // offset === 0 + frame_dig -3 // offset: uint64 + int 0 + == + bz if0_end + + // if0_consequent + // contracts/algo-did.algo.ts:106 + // this.dataBoxes(boxIndex).create(boxIndex === metadata.end ? metadata.endSize : MAX_BOX_SIZE) + frame_dig -2 // boxIndex: uint64 + itob + frame_dig -2 // boxIndex: uint64 + frame_dig -5 // storage key//metadata + box_get + assert + extract 8 8 + btoi + == + bz ternary0_false + frame_dig -5 // storage key//metadata + box_get + assert + extract 17 8 + btoi + b ternary0_end + +ternary0_false: + int 32768 + +ternary0_end: + box_create + +if0_end: + // contracts/algo-did.algo.ts:109 + // this.dataBoxes(boxIndex).replace(offset, data) + frame_dig -2 // boxIndex: uint64 + itob + frame_dig -3 // offset: uint64 + frame_dig -4 // data: bytes + box_replace + retsub + +// finishUpload(address)void +// +// +// Mark uploading as false +// +// @param pubKey The address of the DID +abi_route_finishUpload: + // pubKey: address + txna ApplicationArgs 1 + dup + len + int 32 + == + assert + + // execute finishUpload(address)void + callsub finishUpload + int 1 + return + +finishUpload: + proto 1 0 + + // contracts/algo-did.algo.ts:119 + // assert(this.txn.sender === globals.creatorAddress) + txn Sender + global CreatorAddress + == + assert + + // contracts/algo-did.algo.ts:121 + // this.metadata(pubKey).value.status = READY + frame_dig -1 // pubKey: address + int 16 + byte 0x01 + box_replace + retsub + +// startDelete(address)void +// +// Starts the deletion process for the data associated with a DID +// +// @param pubKey The address of the DID +abi_route_startDelete: + byte 0x // push empty bytes to fill the stack frame for this subroutine's local variables + + // pubKey: address + txna ApplicationArgs 1 + dup + len + int 32 + == + assert + + // execute startDelete(address)void + callsub startDelete + int 1 + return + +startDelete: + proto 2 0 + + // contracts/algo-did.algo.ts:130 + // assert(this.txn.sender === globals.creatorAddress) + txn Sender + global CreatorAddress + == + assert + + // contracts/algo-did.algo.ts:132 + // metadata = this.metadata(pubKey).value + frame_dig -1 // pubKey: address + frame_bury -2 // storage key//metadata + + // contracts/algo-did.algo.ts:133 + // assert(metadata.status === READY) + frame_dig -2 // storage key//metadata + box_get + assert + extract 16 1 + byte 0x0000000000000001 + b== + assert + + // contracts/algo-did.algo.ts:135 + // metadata.status = DELETING + frame_dig -2 // storage key//metadata + box_get + assert + byte 0x02 + replace2 16 + frame_dig -2 // storage key//metadata + swap + box_put + retsub + +// deleteData(uint64,address)void +// +// Deletes a box of data +// +// @param pubKey The address of the DID +// @param boxIndex The index of the box to delete +abi_route_deleteData: + byte 0x; dup // push empty bytes to fill the stack frame for this subroutine's local variables + + // boxIndex: uint64 + txna ApplicationArgs 2 + btoi + + // pubKey: address + txna ApplicationArgs 1 + dup + len + int 32 + == + assert + + // execute deleteData(uint64,address)void + callsub deleteData + int 1 + return + +deleteData: + proto 4 0 + + // contracts/algo-did.algo.ts:145 + // assert(this.txn.sender === globals.creatorAddress) + txn Sender + global CreatorAddress + == + assert + + // contracts/algo-did.algo.ts:147 + // metadata = this.metadata(pubKey).value + frame_dig -1 // pubKey: address + frame_bury -3 // storage key//metadata + + // contracts/algo-did.algo.ts:148 + // assert(metadata.status === DELETING) + frame_dig -3 // storage key//metadata + box_get + assert + extract 16 1 + byte 0x0000000000000002 + b== + assert + + // contracts/algo-did.algo.ts:149 + // assert(metadata.start <= boxIndex && boxIndex <= metadata.end) + frame_dig -3 // storage key//metadata + box_get + assert + extract 0 8 + btoi + frame_dig -2 // boxIndex: uint64 + <= + dup + bz skip_and1 + frame_dig -2 // boxIndex: uint64 + frame_dig -3 // storage key//metadata + box_get + assert + extract 8 8 + btoi + <= + && + +skip_and1: + assert + + // if1_condition + // contracts/algo-did.algo.ts:151 + // boxIndex !== metadata.start + frame_dig -2 // boxIndex: uint64 + frame_dig -3 // storage key//metadata + box_get + assert + extract 0 8 + btoi + != + bz if1_end + + // if1_consequent + // contracts/algo-did.algo.ts:151 + // assert(metadata.lastDeleted === boxIndex - 1) + frame_dig -3 // storage key//metadata + box_get + assert + extract 25 8 + btoi + frame_dig -2 // boxIndex: uint64 + int 1 + - + == + assert + +if1_end: + // contracts/algo-did.algo.ts:153 + // preMBR = globals.currentApplicationAddress.minBalance + global CurrentApplicationAddress + acct_params_get AcctMinBalance + assert + frame_bury -4 // preMBR: uint64 + + // contracts/algo-did.algo.ts:155 + // this.dataBoxes(boxIndex).delete() + frame_dig -2 // boxIndex: uint64 + itob + box_del + + // if2_condition + // contracts/algo-did.algo.ts:157 + // boxIndex === metadata.end + frame_dig -2 // boxIndex: uint64 + frame_dig -3 // storage key//metadata + box_get + assert + extract 8 8 + btoi + == + bz if2_else + + // if2_consequent + // contracts/algo-did.algo.ts:157 + // this.metadata(pubKey).delete() + frame_dig -1 // pubKey: address + box_del + b if2_end + +if2_else: + // contracts/algo-did.algo.ts:158 + // metadata.lastDeleted = boxIndex + frame_dig -3 // storage key//metadata + box_get + assert + frame_dig -2 // boxIndex: uint64 + itob + replace2 25 + frame_dig -3 // storage key//metadata + swap + box_put + +if2_end: + // contracts/algo-did.algo.ts:160 + // sendPayment({ + // amount: preMBR - globals.currentApplicationAddress.minBalance, + // receiver: this.txn.sender, + // }) + itxn_begin + int pay + itxn_field TypeEnum + + // contracts/algo-did.algo.ts:161 + // amount: preMBR - globals.currentApplicationAddress.minBalance + frame_dig -4 // preMBR: uint64 + global CurrentApplicationAddress + acct_params_get AcctMinBalance + assert + - + itxn_field Amount + + // contracts/algo-did.algo.ts:162 + // receiver: this.txn.sender + txn Sender + itxn_field Receiver + + // Fee field not set, defaulting to 0 + int 0 + itxn_field Fee + + // Submit inner transaction + itxn_submit + retsub + +// updateApplication()void +// +// Allow the contract to be updated by the creator +abi_route_updateApplication: + // execute updateApplication()void + callsub updateApplication + int 1 + return + +updateApplication: + proto 0 0 + + // contracts/algo-did.algo.ts:170 + // assert(this.txn.sender === globals.creatorAddress) + txn Sender + global CreatorAddress + == + assert + retsub + +// dummy()void +// +// Dummy function to add extra box references for deleteData. +// Boxes are 32k, but a single app call can only inlcude enough references to read/write 8k +// at a time. Thus when a box is deleted, we need to add additional dummy calls with box +// references to increase the total read/write budget to 32k. +abi_route_dummy: + // execute dummy()void + callsub dummy + int 1 + return + +dummy: + proto 0 0 + retsub + +abi_route_createApplication: + int 1 + return + +create_NoOp: + method "createApplication()void" + txna ApplicationArgs 0 + match abi_route_createApplication + err + +call_NoOp: + method "startUpload(address,uint64,uint64,pay)void" + method "upload(address,uint64,uint64,byte[])void" + method "finishUpload(address)void" + method "startDelete(address)void" + method "deleteData(address,uint64)void" + method "dummy()void" + txna ApplicationArgs 0 + match abi_route_startUpload abi_route_upload abi_route_finishUpload abi_route_startDelete abi_route_deleteData abi_route_dummy + err + +call_UpdateApplication: + method "updateApplication()void" + txna ApplicationArgs 0 + match abi_route_updateApplication + err \ No newline at end of file diff --git a/reference_contract/AlgoDID.arc32.json b/reference_contract/AlgoDID.arc32.json new file mode 100644 index 0000000..a3317c5 --- /dev/null +++ b/reference_contract/AlgoDID.arc32.json @@ -0,0 +1,223 @@ +{ + "hints": { + "startUpload(address,uint64,uint64,pay)void": { + "call_config": { + "no_op": "CALL" + } + }, + "upload(address,uint64,uint64,byte[])void": { + "call_config": { + "no_op": "CALL" + } + }, + "finishUpload(address)void": { + "call_config": { + "no_op": "CALL" + } + }, + "startDelete(address)void": { + "call_config": { + "no_op": "CALL" + } + }, + "deleteData(address,uint64)void": { + "call_config": { + "no_op": "CALL" + } + }, + "updateApplication()void": { + "call_config": { + "update_application": "CALL" + } + }, + "dummy()void": { + "call_config": { + "no_op": "CALL" + } + }, + "createApplication()void": { + "call_config": { + "no_op": "CREATE" + } + } + }, + "bare_call_config": { + "no_op": "NEVER", + "opt_in": "NEVER", + "close_out": "NEVER", + "update_application": "NEVER", + "delete_application": "NEVER" + }, + "schema": { + "local": { + "declared": {}, + "reserved": {} + }, + "global": { + "declared": { + "currentIndex": { + "type": "uint64", + "key": "currentIndex" + } + }, + "reserved": {} + } + }, + "state": { + "global": { + "num_byte_slices": 0, + "num_uints": 1 + }, + "local": { + "num_byte_slices": 0, + "num_uints": 0 + } + }, + "source": { + "approval": "#pragma version 9

// This TEAL was generated by TEALScript v0.51.1
// https://github.com/algorand-devrel/TEALScript

// This contract is compliant with and/or implements the following ARCs: [ ARC4 ]

// The following ten lines of TEAL handle initial program flow
// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed
// Here, action refers to the OnComplete in combination with whether the app is being created or called
// Every possible action for this contract is represented in the switch statement
// If the action is not implmented in the contract, its repsective branch will be "NOT_IMPLMENTED" which just contains "err"
txn ApplicationID
int 0
>
int 6
*
txn OnCompletion
+
switch create_NoOp NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED call_NoOp NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED call_UpdateApplication

NOT_IMPLEMENTED:
	err

// startUpload(pay,uint64,uint64,address)void
//
// 
// Allocate boxes to begin data upload process
// 
// @param pubKey The pubkey of the DID
// @param numBoxes The number of boxes that the data will take up
// @param endBoxSize The size of the last box
// @param mbrPayment Payment from the uploader to cover the box MBR
abi_route_startUpload:
	byte 0x; dupn 3 // push empty bytes to fill the stack frame for this subroutine's local variables

	// mbrPayment: pay
	txn GroupIndex
	int 1
	-
	dup
	gtxns TypeEnum
	int pay
	==
	assert

	// endBoxSize: uint64
	txna ApplicationArgs 3
	btoi

	// numBoxes: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute startUpload(pay,uint64,uint64,address)void
	callsub startUpload
	int 1
	return

startUpload:
	proto 8 0

	// contracts/algo-did.algo.ts:64
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:66
	// startBox = this.currentIndex.value
	byte 0x63757272656e74496e646578 // "currentIndex"
	app_global_get
	frame_bury -5 // startBox: uint64

	// contracts/algo-did.algo.ts:67
	// endBox = startBox + numBoxes - 1
	frame_dig -5 // startBox: uint64
	frame_dig -2 // numBoxes: uint64
	+
	int 1
	-
	frame_bury -6 // endBox: uint64

	// contracts/algo-did.algo.ts:69
	// metadata: Metadata = {
	//       start: startBox, end: endBox, status: UPLOADING, endSize: endBoxSize, lastDeleted: 0,
	//     }
	frame_dig -5 // startBox: uint64
	itob
	frame_dig -6 // endBox: uint64
	itob
	concat
	byte 0x00
	byte 0x00
	bitlen
	int 8
	<=
	assert
	byte 0xFF
	b&
	concat
	frame_dig -3 // endBoxSize: uint64
	itob
	concat
	byte 0x0000000000000000
	concat
	frame_bury -7 // metadata: Metadata

	// contracts/algo-did.algo.ts:73
	// assert(!this.metadata(pubKey).exists)
	frame_dig -1 // pubKey: address
	box_len
	swap
	pop
	!
	assert

	// contracts/algo-did.algo.ts:75
	// this.metadata(pubKey).value = metadata
	frame_dig -1 // pubKey: address
	frame_dig -7 // metadata: Metadata
	box_put

	// contracts/algo-did.algo.ts:77
	// this.currentIndex.value = endBox + 1
	byte 0x63757272656e74496e646578 // "currentIndex"
	frame_dig -6 // endBox: uint64
	int 1
	+
	app_global_put

	// contracts/algo-did.algo.ts:79
	// totalCost = numBoxes * COST_PER_BOX // cost of data boxes
	//     + (numBoxes - 1) * MAX_BOX_SIZE * COST_PER_BYTE // cost of data
	//     + numBoxes * 8 * COST_PER_BYTE // cost of data keys
	//     + endBoxSize * COST_PER_BYTE // cost of last data box
	//     + COST_PER_BOX + (8 + 8 + 1 + 8 + 32 + 8) * COST_PER_BYTE
	frame_dig -2 // numBoxes: uint64
	int 2500
	*
	frame_dig -2 // numBoxes: uint64
	int 1
	-
	int 32768
	*
	int 400
	*
	+
	frame_dig -2 // numBoxes: uint64
	int 8
	*
	int 400
	*
	+
	frame_dig -3 // endBoxSize: uint64
	int 400
	*
	+
	int 2500
	+
	int 26000
	+
	frame_bury -8 // totalCost: uint64

	// contracts/algo-did.algo.ts:85
	// assert(mbrPayment.amount === totalCost)
	frame_dig -4 // mbrPayment: pay
	gtxns Amount
	frame_dig -8 // totalCost: uint64
	==
	assert

	// contracts/algo-did.algo.ts:86
	// assert(mbrPayment.receiver === this.app.address)
	frame_dig -4 // mbrPayment: pay
	gtxns Receiver
	global CurrentApplicationAddress
	==
	assert
	retsub

// upload(bytes,uint64,uint64,address)void
//
// 
// Upload data to a specific offset in a box
// 
// @param pubKey The pubkey of the DID
// @param boxIndex The index of the box to upload the given chunk of data to
// @param offset The offset within the box to start writing the data
// @param data The data to write
abi_route_upload:
	byte 0x // push empty bytes to fill the stack frame for this subroutine's local variables

	// data: byte[]
	txna ApplicationArgs 4
	extract 2 0

	// offset: uint64
	txna ApplicationArgs 3
	btoi

	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute upload(bytes,uint64,uint64,address)void
	callsub upload
	int 1
	return

upload:
	proto 5 0

	// contracts/algo-did.algo.ts:99
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:101
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: address
	frame_bury -5 // storage key//metadata

	// contracts/algo-did.algo.ts:102
	// assert(metadata.status === UPLOADING)
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 16 1
	byte 0x0000000000000000
	b==
	assert

	// contracts/algo-did.algo.ts:103
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 0 8
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz skip_and0
	frame_dig -2 // boxIndex: uint64
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 8 8
	btoi
	<=
	&&

skip_and0:
	assert

	// if0_condition
	// contracts/algo-did.algo.ts:105
	// offset === 0
	frame_dig -3 // offset: uint64
	int 0
	==
	bz if0_end

	// if0_consequent
	// contracts/algo-did.algo.ts:106
	// this.dataBoxes(boxIndex).create(boxIndex === metadata.end ? metadata.endSize : MAX_BOX_SIZE)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -2 // boxIndex: uint64
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 8 8
	btoi
	==
	bz ternary0_false
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 17 8
	btoi
	b ternary0_end

ternary0_false:
	int 32768

ternary0_end:
	box_create

if0_end:
	// contracts/algo-did.algo.ts:109
	// this.dataBoxes(boxIndex).replace(offset, data)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -3 // offset: uint64
	frame_dig -4 // data: bytes
	box_replace
	retsub

// finishUpload(address)void
//
// 
// Mark uploading as false
// 
// @param pubKey The address of the DID
abi_route_finishUpload:
	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute finishUpload(address)void
	callsub finishUpload
	int 1
	return

finishUpload:
	proto 1 0

	// contracts/algo-did.algo.ts:119
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:121
	// this.metadata(pubKey).value.status = READY
	frame_dig -1 // pubKey: address
	int 16
	byte 0x01
	box_replace
	retsub

// startDelete(address)void
//
// Starts the deletion process for the data associated with a DID
// 
// @param pubKey The address of the DID
abi_route_startDelete:
	byte 0x // push empty bytes to fill the stack frame for this subroutine's local variables

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute startDelete(address)void
	callsub startDelete
	int 1
	return

startDelete:
	proto 2 0

	// contracts/algo-did.algo.ts:130
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:132
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: address
	frame_bury -2 // storage key//metadata

	// contracts/algo-did.algo.ts:133
	// assert(metadata.status === READY)
	frame_dig -2 // storage key//metadata
	box_get
	assert
	extract 16 1
	byte 0x0000000000000001
	b==
	assert

	// contracts/algo-did.algo.ts:135
	// metadata.status = DELETING
	frame_dig -2 // storage key//metadata
	box_get
	assert
	byte 0x02
	replace2 16
	frame_dig -2 // storage key//metadata
	swap
	box_put
	retsub

// deleteData(uint64,address)void
//
// Deletes a box of data
// 
// @param pubKey The address of the DID
// @param boxIndex The index of the box to delete
abi_route_deleteData:
	byte 0x; dup // push empty bytes to fill the stack frame for this subroutine's local variables

	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute deleteData(uint64,address)void
	callsub deleteData
	int 1
	return

deleteData:
	proto 4 0

	// contracts/algo-did.algo.ts:145
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:147
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: address
	frame_bury -3 // storage key//metadata

	// contracts/algo-did.algo.ts:148
	// assert(metadata.status === DELETING)
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 16 1
	byte 0x0000000000000002
	b==
	assert

	// contracts/algo-did.algo.ts:149
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 0 8
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz skip_and1
	frame_dig -2 // boxIndex: uint64
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 8 8
	btoi
	<=
	&&

skip_and1:
	assert

	// if1_condition
	// contracts/algo-did.algo.ts:151
	// boxIndex !== metadata.start
	frame_dig -2 // boxIndex: uint64
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 0 8
	btoi
	!=
	bz if1_end

	// if1_consequent
	// contracts/algo-did.algo.ts:151
	// assert(metadata.lastDeleted === boxIndex - 1)
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 25 8
	btoi
	frame_dig -2 // boxIndex: uint64
	int 1
	-
	==
	assert

if1_end:
	// contracts/algo-did.algo.ts:153
	// preMBR = globals.currentApplicationAddress.minBalance
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	assert
	frame_bury -4 // preMBR: uint64

	// contracts/algo-did.algo.ts:155
	// this.dataBoxes(boxIndex).delete()
	frame_dig -2 // boxIndex: uint64
	itob
	box_del

	// if2_condition
	// contracts/algo-did.algo.ts:157
	// boxIndex === metadata.end
	frame_dig -2 // boxIndex: uint64
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 8 8
	btoi
	==
	bz if2_else

	// if2_consequent
	// contracts/algo-did.algo.ts:157
	// this.metadata(pubKey).delete()
	frame_dig -1 // pubKey: address
	box_del
	b if2_end

if2_else:
	// contracts/algo-did.algo.ts:158
	// metadata.lastDeleted = boxIndex
	frame_dig -3 // storage key//metadata
	box_get
	assert
	frame_dig -2 // boxIndex: uint64
	itob
	replace2 25
	frame_dig -3 // storage key//metadata
	swap
	box_put

if2_end:
	// contracts/algo-did.algo.ts:160
	// sendPayment({
	//       amount: preMBR - globals.currentApplicationAddress.minBalance,
	//       receiver: this.txn.sender,
	//     })
	itxn_begin
	int pay
	itxn_field TypeEnum

	// contracts/algo-did.algo.ts:161
	// amount: preMBR - globals.currentApplicationAddress.minBalance
	frame_dig -4 // preMBR: uint64
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	assert
	-
	itxn_field Amount

	// contracts/algo-did.algo.ts:162
	// receiver: this.txn.sender
	txn Sender
	itxn_field Receiver

	// Fee field not set, defaulting to 0
	int 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// updateApplication()void
//
// Allow the contract to be updated by the creator
abi_route_updateApplication:
	// execute updateApplication()void
	callsub updateApplication
	int 1
	return

updateApplication:
	proto 0 0

	// contracts/algo-did.algo.ts:170
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert
	retsub

// dummy()void
//
// Dummy function to add extra box references for deleteData.
// Boxes are 32k, but a single app call can only inlcude enough references to read/write 8k
// at a time. Thus when a box is deleted, we need to add additional dummy calls with box
// references to increase the total read/write budget to 32k.
abi_route_dummy:
	// execute dummy()void
	callsub dummy
	int 1
	return

dummy:
	proto 0 0
	retsub

abi_route_createApplication:
	int 1
	return

create_NoOp:
	method "createApplication()void"
	txna ApplicationArgs 0
	match abi_route_createApplication
	err

call_NoOp:
	method "startUpload(address,uint64,uint64,pay)void"
	method "upload(address,uint64,uint64,byte[])void"
	method "finishUpload(address)void"
	method "startDelete(address)void"
	method "deleteData(address,uint64)void"
	method "dummy()void"
	txna ApplicationArgs 0
	match abi_route_startUpload abi_route_upload abi_route_finishUpload abi_route_startDelete abi_route_deleteData abi_route_dummy
	err

call_UpdateApplication:
	method "updateApplication()void"
	txna ApplicationArgs 0
	match abi_route_updateApplication
	err", + "clear": "I3ByYWdtYSB2ZXJzaW9uIDkKaW50IDE=" + }, + "contract": { + "name": "AlgoDID", + "desc": "", + "methods": [ + { + "name": "startUpload", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The pubkey of the DID" + }, + { + "name": "numBoxes", + "type": "uint64", + "desc": "The number of boxes that the data will take up" + }, + { + "name": "endBoxSize", + "type": "uint64", + "desc": "The size of the last box" + }, + { + "name": "mbrPayment", + "type": "pay", + "desc": "Payment from the uploader to cover the box MBR" + } + ], + "desc": "Allocate boxes to begin data upload process", + "returns": { + "type": "void", + "desc": "" + } + }, + { + "name": "upload", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The pubkey of the DID" + }, + { + "name": "boxIndex", + "type": "uint64", + "desc": "The index of the box to upload the given chunk of data to" + }, + { + "name": "offset", + "type": "uint64", + "desc": "The offset within the box to start writing the data" + }, + { + "name": "data", + "type": "byte[]", + "desc": "The data to write" + } + ], + "desc": "Upload data to a specific offset in a box", + "returns": { + "type": "void", + "desc": "" + } + }, + { + "name": "finishUpload", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + } + ], + "desc": "Mark uploading as false", + "returns": { + "type": "void", + "desc": "" + } + }, + { + "name": "startDelete", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + } + ], + "desc": "Starts the deletion process for the data associated with a DID", + "returns": { + "type": "void", + "desc": "" + } + }, + { + "name": "deleteData", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + }, + { + "name": "boxIndex", + "type": "uint64", + "desc": "The index of the box to delete" + } + ], + "desc": "Deletes a box of data", + "returns": { + "type": "void", + "desc": "" + } + }, + { + "name": "updateApplication", + "args": [], + "desc": "Allow the contract to be updated by the creator", + "returns": { + "type": "void", + "desc": "" + } + }, + { + "name": "dummy", + "args": [], + "desc": "Dummy function to add extra box references for deleteData.Boxes are 32k, but a single app call can only inlcude enough references to read/write 8kat a time. Thus when a box is deleted, we need to add additional dummy calls with boxreferences to increase the total read/write budget to 32k.", + "returns": { + "type": "void", + "desc": "" + } + }, + { + "name": "createApplication", + "desc": "", + "returns": { + "type": "void", + "desc": "" + }, + "args": [] + } + ] + } +} \ No newline at end of file diff --git a/reference_contract/AlgoDID.arc4.json b/reference_contract/AlgoDID.arc4.json new file mode 100644 index 0000000..a62273e --- /dev/null +++ b/reference_contract/AlgoDID.arc4.json @@ -0,0 +1,143 @@ +{ + "name": "AlgoDID", + "desc": "", + "methods": [ + { + "name": "startUpload", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The pubkey of the DID" + }, + { + "name": "numBoxes", + "type": "uint64", + "desc": "The number of boxes that the data will take up" + }, + { + "name": "endBoxSize", + "type": "uint64", + "desc": "The size of the last box" + }, + { + "name": "mbrPayment", + "type": "pay", + "desc": "Payment from the uploader to cover the box MBR" + } + ], + "desc": "Allocate boxes to begin data upload process", + "returns": { + "type": "void", + "desc": "" + } + }, + { + "name": "upload", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The pubkey of the DID" + }, + { + "name": "boxIndex", + "type": "uint64", + "desc": "The index of the box to upload the given chunk of data to" + }, + { + "name": "offset", + "type": "uint64", + "desc": "The offset within the box to start writing the data" + }, + { + "name": "data", + "type": "byte[]", + "desc": "The data to write" + } + ], + "desc": "Upload data to a specific offset in a box", + "returns": { + "type": "void", + "desc": "" + } + }, + { + "name": "finishUpload", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + } + ], + "desc": "Mark uploading as false", + "returns": { + "type": "void", + "desc": "" + } + }, + { + "name": "startDelete", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + } + ], + "desc": "Starts the deletion process for the data associated with a DID", + "returns": { + "type": "void", + "desc": "" + } + }, + { + "name": "deleteData", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + }, + { + "name": "boxIndex", + "type": "uint64", + "desc": "The index of the box to delete" + } + ], + "desc": "Deletes a box of data", + "returns": { + "type": "void", + "desc": "" + } + }, + { + "name": "updateApplication", + "args": [], + "desc": "Allow the contract to be updated by the creator", + "returns": { + "type": "void", + "desc": "" + } + }, + { + "name": "dummy", + "args": [], + "desc": "Dummy function to add extra box references for deleteData.Boxes are 32k, but a single app call can only inlcude enough references to read/write 8kat a time. Thus when a box is deleted, we need to add additional dummy calls with boxreferences to increase the total read/write budget to 32k.", + "returns": { + "type": "void", + "desc": "" + } + }, + { + "name": "createApplication", + "desc": "", + "returns": { + "type": "void", + "desc": "" + }, + "args": [] + } + ] +} \ No newline at end of file diff --git a/reference_contract/README.md b/reference_contract/README.md new file mode 100644 index 0000000..fb06c5d --- /dev/null +++ b/reference_contract/README.md @@ -0,0 +1,7 @@ +# Reference Contract + +This is the reference implementation of the contract that will be used to store the DIDDocuments for `did:algo`. This is the contract that is used by the CLI tool by default when deploying a new contract. + +It should be noted that the `did:algo` spec will work with any contract that implements the ABI interface defined in [the ARC4 JSON description](./AlgDID.arc4.json) and the `did:algo` [spec](../SPEC.md). + +The client-side code for interacting with this contract can be seen [here](../client/internal/main.go). diff --git a/reference_contract/algo-did.algo.ts b/reference_contract/algo-did.algo.ts new file mode 100644 index 0000000..248aced --- /dev/null +++ b/reference_contract/algo-did.algo.ts @@ -0,0 +1,180 @@ +// eslint-disable-next-line import/no-extraneous-dependencies +import { Contract } from '@algorandfoundation/tealscript'; + +/** Metadata about DID Document data */ +type Metadata = { + /** start - The index of the box at which the data starts */ + start: uint64, + + /** end - The index of the box at which the data ends */ + end: uint64, + + /** status - 0 if uploading, 1 if ready, 2 if deleting */ + status: uint<8>, + + /** The size of the last box */ + endSize: uint64, + + /** + * The index of the last box that was deleted. Used to ensure all boxes are deleted in order + * To prevent any missed boxes (thus missed MBR refund) + */ + lastDeleted: uint64 +}; + +/** Indicates the data is still being uploaded */ +const UPLOADING: uint<8> = 0; + +/** Indicates the data is done uploading and can be safely read */ +const READY: uint<8> = 1; + +/** Indicates the data is currently being deleted */ +const DELETING: uint<8> = 2; + +const COST_PER_BYTE = 400; +const COST_PER_BOX = 2500; +const MAX_BOX_SIZE = 32768; + +// eslint-disable-next-line no-unused-vars +class AlgoDID extends Contract { + /** The boxes that contain the data, indexed by uint64 */ + dataBoxes = BoxMap(); + + /** Metadata for a given pubkey */ + metadata = BoxMap(); + + /** The index of the next box to be created */ + currentIndex = GlobalStateKey(); + + /** + * + * Allocate boxes to begin data upload process + * + * @param pubKey The pubkey of the DID + * @param numBoxes The number of boxes that the data will take up + * @param endBoxSize The size of the last box + * @param mbrPayment Payment from the uploader to cover the box MBR + */ + startUpload( + pubKey: Address, + numBoxes: uint64, + endBoxSize: uint64, + mbrPayment: PayTxn, + ): void { + assert(this.txn.sender === globals.creatorAddress); + + const startBox = this.currentIndex.value; + const endBox = startBox + numBoxes - 1; + + const metadata: Metadata = { + start: startBox, end: endBox, status: UPLOADING, endSize: endBoxSize, lastDeleted: 0, + }; + + assert(!this.metadata(pubKey).exists); + + this.metadata(pubKey).value = metadata; + + this.currentIndex.value = endBox + 1; + + const totalCost = numBoxes * COST_PER_BOX // cost of data boxes + + (numBoxes - 1) * MAX_BOX_SIZE * COST_PER_BYTE // cost of data + + numBoxes * 8 * COST_PER_BYTE // cost of data keys + + endBoxSize * COST_PER_BYTE // cost of last data box + + COST_PER_BOX + (8 + 8 + 1 + 8 + 32 + 8) * COST_PER_BYTE; // cost of metadata box + + assert(mbrPayment.amount === totalCost); + assert(mbrPayment.receiver === this.app.address); + } + + /** + * + * Upload data to a specific offset in a box + * + * @param pubKey The pubkey of the DID + * @param boxIndex The index of the box to upload the given chunk of data to + * @param offset The offset within the box to start writing the data + * @param data The data to write + */ + upload(pubKey: Address, boxIndex: uint64, offset: uint64, data: bytes): void { + assert(this.txn.sender === globals.creatorAddress); + + const metadata = this.metadata(pubKey).value; + assert(metadata.status === UPLOADING); + assert(metadata.start <= boxIndex && boxIndex <= metadata.end); + + if (offset === 0) { + this.dataBoxes(boxIndex).create(boxIndex === metadata.end ? metadata.endSize : MAX_BOX_SIZE); + } + + this.dataBoxes(boxIndex).replace(offset, data); + } + + /** + * + * Mark uploading as false + * + * @param pubKey The address of the DID + */ + finishUpload(pubKey: Address): void { + assert(this.txn.sender === globals.creatorAddress); + + this.metadata(pubKey).value.status = READY; + } + + /** + * Starts the deletion process for the data associated with a DID + * + * @param pubKey The address of the DID + */ + startDelete(pubKey: Address): void { + assert(this.txn.sender === globals.creatorAddress); + + const metadata = this.metadata(pubKey).value; + assert(metadata.status === READY); + + metadata.status = DELETING; + } + + /** + * Deletes a box of data + * + * @param pubKey The address of the DID + * @param boxIndex The index of the box to delete + */ + deleteData(pubKey: Address, boxIndex: uint64): void { + assert(this.txn.sender === globals.creatorAddress); + + const metadata = this.metadata(pubKey).value; + assert(metadata.status === DELETING); + assert(metadata.start <= boxIndex && boxIndex <= metadata.end); + + if (boxIndex !== metadata.start) assert(metadata.lastDeleted === boxIndex - 1); + + const preMBR = globals.currentApplicationAddress.minBalance; + + this.dataBoxes(boxIndex).delete(); + + if (boxIndex === metadata.end) this.metadata(pubKey).delete(); + else metadata.lastDeleted = boxIndex; + + sendPayment({ + amount: preMBR - globals.currentApplicationAddress.minBalance, + receiver: this.txn.sender, + }); + } + + /** + * Allow the contract to be updated by the creator + */ + updateApplication(): void { + assert(this.txn.sender === globals.creatorAddress); + } + + /** + * Dummy function to add extra box references for deleteData. + * Boxes are 32k, but a single app call can only inlcude enough references to read/write 8k + * at a time. Thus when a box is deleted, we need to add additional dummy calls with box + * references to increase the total read/write budget to 32k. + */ + dummy(): void {} +} From 0b6691b7c69a8e92e8a51d348c708075c4dc58be Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Wed, 19 Jun 2024 13:20:00 -0400 Subject: [PATCH 2/9] add contract with tests --- reference_contract/.eslintrc.js | 57 + reference_contract/.gitignore | 2 + reference_contract/AlgoDID.approval.teal | 655 - reference_contract/AlgoDID.arc32.json | 223 - reference_contract/AlgoDID.arc4.json | 143 - reference_contract/README.md | 7 - reference_contract/__test__/DIDocument.json | 93 + reference_contract/__test__/TEAL.pdf | Bin 0 -> 304979 bytes reference_contract/__test__/algo-did.test.ts | 151 + reference_contract/__test__/common.ts | 6 + .../{ => contracts}/algo-did.algo.ts | 0 .../contracts/clients/AlgoDIDClient.ts | 1047 ++ reference_contract/jest.config.js | 5 + reference_contract/package-lock.json | 10737 ++++++++++++++++ reference_contract/package.json | 31 + reference_contract/src/index.ts | 362 + reference_contract/tsconfig.json | 103 + 17 files changed, 12594 insertions(+), 1028 deletions(-) create mode 100644 reference_contract/.eslintrc.js create mode 100644 reference_contract/.gitignore delete mode 100644 reference_contract/AlgoDID.approval.teal delete mode 100644 reference_contract/AlgoDID.arc32.json delete mode 100644 reference_contract/AlgoDID.arc4.json delete mode 100644 reference_contract/README.md create mode 100644 reference_contract/__test__/DIDocument.json create mode 100644 reference_contract/__test__/TEAL.pdf create mode 100644 reference_contract/__test__/algo-did.test.ts create mode 100644 reference_contract/__test__/common.ts rename reference_contract/{ => contracts}/algo-did.algo.ts (100%) create mode 100644 reference_contract/contracts/clients/AlgoDIDClient.ts create mode 100644 reference_contract/jest.config.js create mode 100644 reference_contract/package-lock.json create mode 100644 reference_contract/package.json create mode 100644 reference_contract/src/index.ts create mode 100644 reference_contract/tsconfig.json diff --git a/reference_contract/.eslintrc.js b/reference_contract/.eslintrc.js new file mode 100644 index 0000000..69b3fcb --- /dev/null +++ b/reference_contract/.eslintrc.js @@ -0,0 +1,57 @@ +module.exports = { + env: { + browser: true, + es2021: true, + }, + extends: [ + 'airbnb-base', + 'plugin:import/errors', + 'plugin:import/warnings', + 'plugin:import/typescript', + ], + parser: '@typescript-eslint/parser', + parserOptions: { + ecmaVersion: 'latest', + sourceType: 'module', + }, + plugins: [ + '@typescript-eslint', + ], + rules: { + '@typescript-eslint/no-explicit-any': 'error', + '@typescript-eslint/ban-ts-comment': 'warn', + 'import/prefer-default-export': 'off', + 'import/extensions': [ + 'error', + 'ignorePackages', + { + js: 'never', + jsx: 'never', + ts: 'never', + tsx: 'never', + }, + ], + 'import/no-extraneous-dependencies': [ + 'error', + { + devDependencies: [ + '**/*.test.ts', + ], + }, + ], + }, + overrides: [ + { + files: ['*.algo.ts'], + rules: { + 'object-shorthand': 'off', + 'class-methods-use-this': 'off', + 'no-undef': 'off', + 'max-classes-per-file': 'off', + 'no-bitwise': 'off', + 'operator-assignment': 'off', + 'prefer-template': 'off', + }, + }, + ], +}; diff --git a/reference_contract/.gitignore b/reference_contract/.gitignore new file mode 100644 index 0000000..bd0a936 --- /dev/null +++ b/reference_contract/.gitignore @@ -0,0 +1,2 @@ +node_modules/ +contracts/artifacts \ No newline at end of file diff --git a/reference_contract/AlgoDID.approval.teal b/reference_contract/AlgoDID.approval.teal deleted file mode 100644 index 69107f4..0000000 --- a/reference_contract/AlgoDID.approval.teal +++ /dev/null @@ -1,655 +0,0 @@ -#pragma version 9 - -// This TEAL was generated by TEALScript v0.51.1 -// https://github.com/algorand-devrel/TEALScript - -// This contract is compliant with and/or implements the following ARCs: [ ARC4 ] - -// The following ten lines of TEAL handle initial program flow -// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed -// Here, action refers to the OnComplete in combination with whether the app is being created or called -// Every possible action for this contract is represented in the switch statement -// If the action is not implmented in the contract, its repsective branch will be "NOT_IMPLMENTED" which just contains "err" -txn ApplicationID -int 0 -> -int 6 -* -txn OnCompletion -+ -switch create_NoOp NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED call_NoOp NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED call_UpdateApplication - -NOT_IMPLEMENTED: - err - -// startUpload(pay,uint64,uint64,address)void -// -// -// Allocate boxes to begin data upload process -// -// @param pubKey The pubkey of the DID -// @param numBoxes The number of boxes that the data will take up -// @param endBoxSize The size of the last box -// @param mbrPayment Payment from the uploader to cover the box MBR -abi_route_startUpload: - byte 0x; dupn 3 // push empty bytes to fill the stack frame for this subroutine's local variables - - // mbrPayment: pay - txn GroupIndex - int 1 - - - dup - gtxns TypeEnum - int pay - == - assert - - // endBoxSize: uint64 - txna ApplicationArgs 3 - btoi - - // numBoxes: uint64 - txna ApplicationArgs 2 - btoi - - // pubKey: address - txna ApplicationArgs 1 - dup - len - int 32 - == - assert - - // execute startUpload(pay,uint64,uint64,address)void - callsub startUpload - int 1 - return - -startUpload: - proto 8 0 - - // contracts/algo-did.algo.ts:64 - // assert(this.txn.sender === globals.creatorAddress) - txn Sender - global CreatorAddress - == - assert - - // contracts/algo-did.algo.ts:66 - // startBox = this.currentIndex.value - byte 0x63757272656e74496e646578 // "currentIndex" - app_global_get - frame_bury -5 // startBox: uint64 - - // contracts/algo-did.algo.ts:67 - // endBox = startBox + numBoxes - 1 - frame_dig -5 // startBox: uint64 - frame_dig -2 // numBoxes: uint64 - + - int 1 - - - frame_bury -6 // endBox: uint64 - - // contracts/algo-did.algo.ts:69 - // metadata: Metadata = { - // start: startBox, end: endBox, status: UPLOADING, endSize: endBoxSize, lastDeleted: 0, - // } - frame_dig -5 // startBox: uint64 - itob - frame_dig -6 // endBox: uint64 - itob - concat - byte 0x00 - byte 0x00 - bitlen - int 8 - <= - assert - byte 0xFF - b& - concat - frame_dig -3 // endBoxSize: uint64 - itob - concat - byte 0x0000000000000000 - concat - frame_bury -7 // metadata: Metadata - - // contracts/algo-did.algo.ts:73 - // assert(!this.metadata(pubKey).exists) - frame_dig -1 // pubKey: address - box_len - swap - pop - ! - assert - - // contracts/algo-did.algo.ts:75 - // this.metadata(pubKey).value = metadata - frame_dig -1 // pubKey: address - frame_dig -7 // metadata: Metadata - box_put - - // contracts/algo-did.algo.ts:77 - // this.currentIndex.value = endBox + 1 - byte 0x63757272656e74496e646578 // "currentIndex" - frame_dig -6 // endBox: uint64 - int 1 - + - app_global_put - - // contracts/algo-did.algo.ts:79 - // totalCost = numBoxes * COST_PER_BOX // cost of data boxes - // + (numBoxes - 1) * MAX_BOX_SIZE * COST_PER_BYTE // cost of data - // + numBoxes * 8 * COST_PER_BYTE // cost of data keys - // + endBoxSize * COST_PER_BYTE // cost of last data box - // + COST_PER_BOX + (8 + 8 + 1 + 8 + 32 + 8) * COST_PER_BYTE - frame_dig -2 // numBoxes: uint64 - int 2500 - * - frame_dig -2 // numBoxes: uint64 - int 1 - - - int 32768 - * - int 400 - * - + - frame_dig -2 // numBoxes: uint64 - int 8 - * - int 400 - * - + - frame_dig -3 // endBoxSize: uint64 - int 400 - * - + - int 2500 - + - int 26000 - + - frame_bury -8 // totalCost: uint64 - - // contracts/algo-did.algo.ts:85 - // assert(mbrPayment.amount === totalCost) - frame_dig -4 // mbrPayment: pay - gtxns Amount - frame_dig -8 // totalCost: uint64 - == - assert - - // contracts/algo-did.algo.ts:86 - // assert(mbrPayment.receiver === this.app.address) - frame_dig -4 // mbrPayment: pay - gtxns Receiver - global CurrentApplicationAddress - == - assert - retsub - -// upload(bytes,uint64,uint64,address)void -// -// -// Upload data to a specific offset in a box -// -// @param pubKey The pubkey of the DID -// @param boxIndex The index of the box to upload the given chunk of data to -// @param offset The offset within the box to start writing the data -// @param data The data to write -abi_route_upload: - byte 0x // push empty bytes to fill the stack frame for this subroutine's local variables - - // data: byte[] - txna ApplicationArgs 4 - extract 2 0 - - // offset: uint64 - txna ApplicationArgs 3 - btoi - - // boxIndex: uint64 - txna ApplicationArgs 2 - btoi - - // pubKey: address - txna ApplicationArgs 1 - dup - len - int 32 - == - assert - - // execute upload(bytes,uint64,uint64,address)void - callsub upload - int 1 - return - -upload: - proto 5 0 - - // contracts/algo-did.algo.ts:99 - // assert(this.txn.sender === globals.creatorAddress) - txn Sender - global CreatorAddress - == - assert - - // contracts/algo-did.algo.ts:101 - // metadata = this.metadata(pubKey).value - frame_dig -1 // pubKey: address - frame_bury -5 // storage key//metadata - - // contracts/algo-did.algo.ts:102 - // assert(metadata.status === UPLOADING) - frame_dig -5 // storage key//metadata - box_get - assert - extract 16 1 - byte 0x0000000000000000 - b== - assert - - // contracts/algo-did.algo.ts:103 - // assert(metadata.start <= boxIndex && boxIndex <= metadata.end) - frame_dig -5 // storage key//metadata - box_get - assert - extract 0 8 - btoi - frame_dig -2 // boxIndex: uint64 - <= - dup - bz skip_and0 - frame_dig -2 // boxIndex: uint64 - frame_dig -5 // storage key//metadata - box_get - assert - extract 8 8 - btoi - <= - && - -skip_and0: - assert - - // if0_condition - // contracts/algo-did.algo.ts:105 - // offset === 0 - frame_dig -3 // offset: uint64 - int 0 - == - bz if0_end - - // if0_consequent - // contracts/algo-did.algo.ts:106 - // this.dataBoxes(boxIndex).create(boxIndex === metadata.end ? metadata.endSize : MAX_BOX_SIZE) - frame_dig -2 // boxIndex: uint64 - itob - frame_dig -2 // boxIndex: uint64 - frame_dig -5 // storage key//metadata - box_get - assert - extract 8 8 - btoi - == - bz ternary0_false - frame_dig -5 // storage key//metadata - box_get - assert - extract 17 8 - btoi - b ternary0_end - -ternary0_false: - int 32768 - -ternary0_end: - box_create - -if0_end: - // contracts/algo-did.algo.ts:109 - // this.dataBoxes(boxIndex).replace(offset, data) - frame_dig -2 // boxIndex: uint64 - itob - frame_dig -3 // offset: uint64 - frame_dig -4 // data: bytes - box_replace - retsub - -// finishUpload(address)void -// -// -// Mark uploading as false -// -// @param pubKey The address of the DID -abi_route_finishUpload: - // pubKey: address - txna ApplicationArgs 1 - dup - len - int 32 - == - assert - - // execute finishUpload(address)void - callsub finishUpload - int 1 - return - -finishUpload: - proto 1 0 - - // contracts/algo-did.algo.ts:119 - // assert(this.txn.sender === globals.creatorAddress) - txn Sender - global CreatorAddress - == - assert - - // contracts/algo-did.algo.ts:121 - // this.metadata(pubKey).value.status = READY - frame_dig -1 // pubKey: address - int 16 - byte 0x01 - box_replace - retsub - -// startDelete(address)void -// -// Starts the deletion process for the data associated with a DID -// -// @param pubKey The address of the DID -abi_route_startDelete: - byte 0x // push empty bytes to fill the stack frame for this subroutine's local variables - - // pubKey: address - txna ApplicationArgs 1 - dup - len - int 32 - == - assert - - // execute startDelete(address)void - callsub startDelete - int 1 - return - -startDelete: - proto 2 0 - - // contracts/algo-did.algo.ts:130 - // assert(this.txn.sender === globals.creatorAddress) - txn Sender - global CreatorAddress - == - assert - - // contracts/algo-did.algo.ts:132 - // metadata = this.metadata(pubKey).value - frame_dig -1 // pubKey: address - frame_bury -2 // storage key//metadata - - // contracts/algo-did.algo.ts:133 - // assert(metadata.status === READY) - frame_dig -2 // storage key//metadata - box_get - assert - extract 16 1 - byte 0x0000000000000001 - b== - assert - - // contracts/algo-did.algo.ts:135 - // metadata.status = DELETING - frame_dig -2 // storage key//metadata - box_get - assert - byte 0x02 - replace2 16 - frame_dig -2 // storage key//metadata - swap - box_put - retsub - -// deleteData(uint64,address)void -// -// Deletes a box of data -// -// @param pubKey The address of the DID -// @param boxIndex The index of the box to delete -abi_route_deleteData: - byte 0x; dup // push empty bytes to fill the stack frame for this subroutine's local variables - - // boxIndex: uint64 - txna ApplicationArgs 2 - btoi - - // pubKey: address - txna ApplicationArgs 1 - dup - len - int 32 - == - assert - - // execute deleteData(uint64,address)void - callsub deleteData - int 1 - return - -deleteData: - proto 4 0 - - // contracts/algo-did.algo.ts:145 - // assert(this.txn.sender === globals.creatorAddress) - txn Sender - global CreatorAddress - == - assert - - // contracts/algo-did.algo.ts:147 - // metadata = this.metadata(pubKey).value - frame_dig -1 // pubKey: address - frame_bury -3 // storage key//metadata - - // contracts/algo-did.algo.ts:148 - // assert(metadata.status === DELETING) - frame_dig -3 // storage key//metadata - box_get - assert - extract 16 1 - byte 0x0000000000000002 - b== - assert - - // contracts/algo-did.algo.ts:149 - // assert(metadata.start <= boxIndex && boxIndex <= metadata.end) - frame_dig -3 // storage key//metadata - box_get - assert - extract 0 8 - btoi - frame_dig -2 // boxIndex: uint64 - <= - dup - bz skip_and1 - frame_dig -2 // boxIndex: uint64 - frame_dig -3 // storage key//metadata - box_get - assert - extract 8 8 - btoi - <= - && - -skip_and1: - assert - - // if1_condition - // contracts/algo-did.algo.ts:151 - // boxIndex !== metadata.start - frame_dig -2 // boxIndex: uint64 - frame_dig -3 // storage key//metadata - box_get - assert - extract 0 8 - btoi - != - bz if1_end - - // if1_consequent - // contracts/algo-did.algo.ts:151 - // assert(metadata.lastDeleted === boxIndex - 1) - frame_dig -3 // storage key//metadata - box_get - assert - extract 25 8 - btoi - frame_dig -2 // boxIndex: uint64 - int 1 - - - == - assert - -if1_end: - // contracts/algo-did.algo.ts:153 - // preMBR = globals.currentApplicationAddress.minBalance - global CurrentApplicationAddress - acct_params_get AcctMinBalance - assert - frame_bury -4 // preMBR: uint64 - - // contracts/algo-did.algo.ts:155 - // this.dataBoxes(boxIndex).delete() - frame_dig -2 // boxIndex: uint64 - itob - box_del - - // if2_condition - // contracts/algo-did.algo.ts:157 - // boxIndex === metadata.end - frame_dig -2 // boxIndex: uint64 - frame_dig -3 // storage key//metadata - box_get - assert - extract 8 8 - btoi - == - bz if2_else - - // if2_consequent - // contracts/algo-did.algo.ts:157 - // this.metadata(pubKey).delete() - frame_dig -1 // pubKey: address - box_del - b if2_end - -if2_else: - // contracts/algo-did.algo.ts:158 - // metadata.lastDeleted = boxIndex - frame_dig -3 // storage key//metadata - box_get - assert - frame_dig -2 // boxIndex: uint64 - itob - replace2 25 - frame_dig -3 // storage key//metadata - swap - box_put - -if2_end: - // contracts/algo-did.algo.ts:160 - // sendPayment({ - // amount: preMBR - globals.currentApplicationAddress.minBalance, - // receiver: this.txn.sender, - // }) - itxn_begin - int pay - itxn_field TypeEnum - - // contracts/algo-did.algo.ts:161 - // amount: preMBR - globals.currentApplicationAddress.minBalance - frame_dig -4 // preMBR: uint64 - global CurrentApplicationAddress - acct_params_get AcctMinBalance - assert - - - itxn_field Amount - - // contracts/algo-did.algo.ts:162 - // receiver: this.txn.sender - txn Sender - itxn_field Receiver - - // Fee field not set, defaulting to 0 - int 0 - itxn_field Fee - - // Submit inner transaction - itxn_submit - retsub - -// updateApplication()void -// -// Allow the contract to be updated by the creator -abi_route_updateApplication: - // execute updateApplication()void - callsub updateApplication - int 1 - return - -updateApplication: - proto 0 0 - - // contracts/algo-did.algo.ts:170 - // assert(this.txn.sender === globals.creatorAddress) - txn Sender - global CreatorAddress - == - assert - retsub - -// dummy()void -// -// Dummy function to add extra box references for deleteData. -// Boxes are 32k, but a single app call can only inlcude enough references to read/write 8k -// at a time. Thus when a box is deleted, we need to add additional dummy calls with box -// references to increase the total read/write budget to 32k. -abi_route_dummy: - // execute dummy()void - callsub dummy - int 1 - return - -dummy: - proto 0 0 - retsub - -abi_route_createApplication: - int 1 - return - -create_NoOp: - method "createApplication()void" - txna ApplicationArgs 0 - match abi_route_createApplication - err - -call_NoOp: - method "startUpload(address,uint64,uint64,pay)void" - method "upload(address,uint64,uint64,byte[])void" - method "finishUpload(address)void" - method "startDelete(address)void" - method "deleteData(address,uint64)void" - method "dummy()void" - txna ApplicationArgs 0 - match abi_route_startUpload abi_route_upload abi_route_finishUpload abi_route_startDelete abi_route_deleteData abi_route_dummy - err - -call_UpdateApplication: - method "updateApplication()void" - txna ApplicationArgs 0 - match abi_route_updateApplication - err \ No newline at end of file diff --git a/reference_contract/AlgoDID.arc32.json b/reference_contract/AlgoDID.arc32.json deleted file mode 100644 index a3317c5..0000000 --- a/reference_contract/AlgoDID.arc32.json +++ /dev/null @@ -1,223 +0,0 @@ -{ - "hints": { - "startUpload(address,uint64,uint64,pay)void": { - "call_config": { - "no_op": "CALL" - } - }, - "upload(address,uint64,uint64,byte[])void": { - "call_config": { - "no_op": "CALL" - } - }, - "finishUpload(address)void": { - "call_config": { - "no_op": "CALL" - } - }, - "startDelete(address)void": { - "call_config": { - "no_op": "CALL" - } - }, - "deleteData(address,uint64)void": { - "call_config": { - "no_op": "CALL" - } - }, - "updateApplication()void": { - "call_config": { - "update_application": "CALL" - } - }, - "dummy()void": { - "call_config": { - "no_op": "CALL" - } - }, - "createApplication()void": { - "call_config": { - "no_op": "CREATE" - } - } - }, - "bare_call_config": { - "no_op": "NEVER", - "opt_in": "NEVER", - "close_out": "NEVER", - "update_application": "NEVER", - "delete_application": "NEVER" - }, - "schema": { - "local": { - "declared": {}, - "reserved": {} - }, - "global": { - "declared": { - "currentIndex": { - "type": "uint64", - "key": "currentIndex" - } - }, - "reserved": {} - } - }, - "state": { - "global": { - "num_byte_slices": 0, - "num_uints": 1 - }, - "local": { - "num_byte_slices": 0, - "num_uints": 0 - } - }, - "source": { - "approval": "#pragma version 9

// This TEAL was generated by TEALScript v0.51.1
// https://github.com/algorand-devrel/TEALScript

// This contract is compliant with and/or implements the following ARCs: [ ARC4 ]

// The following ten lines of TEAL handle initial program flow
// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed
// Here, action refers to the OnComplete in combination with whether the app is being created or called
// Every possible action for this contract is represented in the switch statement
// If the action is not implmented in the contract, its repsective branch will be "NOT_IMPLMENTED" which just contains "err"
txn ApplicationID
int 0
>
int 6
*
txn OnCompletion
+
switch create_NoOp NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED call_NoOp NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED call_UpdateApplication

NOT_IMPLEMENTED:
	err

// startUpload(pay,uint64,uint64,address)void
//
// 
// Allocate boxes to begin data upload process
// 
// @param pubKey The pubkey of the DID
// @param numBoxes The number of boxes that the data will take up
// @param endBoxSize The size of the last box
// @param mbrPayment Payment from the uploader to cover the box MBR
abi_route_startUpload:
	byte 0x; dupn 3 // push empty bytes to fill the stack frame for this subroutine's local variables

	// mbrPayment: pay
	txn GroupIndex
	int 1
	-
	dup
	gtxns TypeEnum
	int pay
	==
	assert

	// endBoxSize: uint64
	txna ApplicationArgs 3
	btoi

	// numBoxes: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute startUpload(pay,uint64,uint64,address)void
	callsub startUpload
	int 1
	return

startUpload:
	proto 8 0

	// contracts/algo-did.algo.ts:64
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:66
	// startBox = this.currentIndex.value
	byte 0x63757272656e74496e646578 // "currentIndex"
	app_global_get
	frame_bury -5 // startBox: uint64

	// contracts/algo-did.algo.ts:67
	// endBox = startBox + numBoxes - 1
	frame_dig -5 // startBox: uint64
	frame_dig -2 // numBoxes: uint64
	+
	int 1
	-
	frame_bury -6 // endBox: uint64

	// contracts/algo-did.algo.ts:69
	// metadata: Metadata = {
	//       start: startBox, end: endBox, status: UPLOADING, endSize: endBoxSize, lastDeleted: 0,
	//     }
	frame_dig -5 // startBox: uint64
	itob
	frame_dig -6 // endBox: uint64
	itob
	concat
	byte 0x00
	byte 0x00
	bitlen
	int 8
	<=
	assert
	byte 0xFF
	b&
	concat
	frame_dig -3 // endBoxSize: uint64
	itob
	concat
	byte 0x0000000000000000
	concat
	frame_bury -7 // metadata: Metadata

	// contracts/algo-did.algo.ts:73
	// assert(!this.metadata(pubKey).exists)
	frame_dig -1 // pubKey: address
	box_len
	swap
	pop
	!
	assert

	// contracts/algo-did.algo.ts:75
	// this.metadata(pubKey).value = metadata
	frame_dig -1 // pubKey: address
	frame_dig -7 // metadata: Metadata
	box_put

	// contracts/algo-did.algo.ts:77
	// this.currentIndex.value = endBox + 1
	byte 0x63757272656e74496e646578 // "currentIndex"
	frame_dig -6 // endBox: uint64
	int 1
	+
	app_global_put

	// contracts/algo-did.algo.ts:79
	// totalCost = numBoxes * COST_PER_BOX // cost of data boxes
	//     + (numBoxes - 1) * MAX_BOX_SIZE * COST_PER_BYTE // cost of data
	//     + numBoxes * 8 * COST_PER_BYTE // cost of data keys
	//     + endBoxSize * COST_PER_BYTE // cost of last data box
	//     + COST_PER_BOX + (8 + 8 + 1 + 8 + 32 + 8) * COST_PER_BYTE
	frame_dig -2 // numBoxes: uint64
	int 2500
	*
	frame_dig -2 // numBoxes: uint64
	int 1
	-
	int 32768
	*
	int 400
	*
	+
	frame_dig -2 // numBoxes: uint64
	int 8
	*
	int 400
	*
	+
	frame_dig -3 // endBoxSize: uint64
	int 400
	*
	+
	int 2500
	+
	int 26000
	+
	frame_bury -8 // totalCost: uint64

	// contracts/algo-did.algo.ts:85
	// assert(mbrPayment.amount === totalCost)
	frame_dig -4 // mbrPayment: pay
	gtxns Amount
	frame_dig -8 // totalCost: uint64
	==
	assert

	// contracts/algo-did.algo.ts:86
	// assert(mbrPayment.receiver === this.app.address)
	frame_dig -4 // mbrPayment: pay
	gtxns Receiver
	global CurrentApplicationAddress
	==
	assert
	retsub

// upload(bytes,uint64,uint64,address)void
//
// 
// Upload data to a specific offset in a box
// 
// @param pubKey The pubkey of the DID
// @param boxIndex The index of the box to upload the given chunk of data to
// @param offset The offset within the box to start writing the data
// @param data The data to write
abi_route_upload:
	byte 0x // push empty bytes to fill the stack frame for this subroutine's local variables

	// data: byte[]
	txna ApplicationArgs 4
	extract 2 0

	// offset: uint64
	txna ApplicationArgs 3
	btoi

	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute upload(bytes,uint64,uint64,address)void
	callsub upload
	int 1
	return

upload:
	proto 5 0

	// contracts/algo-did.algo.ts:99
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:101
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: address
	frame_bury -5 // storage key//metadata

	// contracts/algo-did.algo.ts:102
	// assert(metadata.status === UPLOADING)
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 16 1
	byte 0x0000000000000000
	b==
	assert

	// contracts/algo-did.algo.ts:103
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 0 8
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz skip_and0
	frame_dig -2 // boxIndex: uint64
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 8 8
	btoi
	<=
	&&

skip_and0:
	assert

	// if0_condition
	// contracts/algo-did.algo.ts:105
	// offset === 0
	frame_dig -3 // offset: uint64
	int 0
	==
	bz if0_end

	// if0_consequent
	// contracts/algo-did.algo.ts:106
	// this.dataBoxes(boxIndex).create(boxIndex === metadata.end ? metadata.endSize : MAX_BOX_SIZE)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -2 // boxIndex: uint64
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 8 8
	btoi
	==
	bz ternary0_false
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 17 8
	btoi
	b ternary0_end

ternary0_false:
	int 32768

ternary0_end:
	box_create

if0_end:
	// contracts/algo-did.algo.ts:109
	// this.dataBoxes(boxIndex).replace(offset, data)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -3 // offset: uint64
	frame_dig -4 // data: bytes
	box_replace
	retsub

// finishUpload(address)void
//
// 
// Mark uploading as false
// 
// @param pubKey The address of the DID
abi_route_finishUpload:
	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute finishUpload(address)void
	callsub finishUpload
	int 1
	return

finishUpload:
	proto 1 0

	// contracts/algo-did.algo.ts:119
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:121
	// this.metadata(pubKey).value.status = READY
	frame_dig -1 // pubKey: address
	int 16
	byte 0x01
	box_replace
	retsub

// startDelete(address)void
//
// Starts the deletion process for the data associated with a DID
// 
// @param pubKey The address of the DID
abi_route_startDelete:
	byte 0x // push empty bytes to fill the stack frame for this subroutine's local variables

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute startDelete(address)void
	callsub startDelete
	int 1
	return

startDelete:
	proto 2 0

	// contracts/algo-did.algo.ts:130
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:132
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: address
	frame_bury -2 // storage key//metadata

	// contracts/algo-did.algo.ts:133
	// assert(metadata.status === READY)
	frame_dig -2 // storage key//metadata
	box_get
	assert
	extract 16 1
	byte 0x0000000000000001
	b==
	assert

	// contracts/algo-did.algo.ts:135
	// metadata.status = DELETING
	frame_dig -2 // storage key//metadata
	box_get
	assert
	byte 0x02
	replace2 16
	frame_dig -2 // storage key//metadata
	swap
	box_put
	retsub

// deleteData(uint64,address)void
//
// Deletes a box of data
// 
// @param pubKey The address of the DID
// @param boxIndex The index of the box to delete
abi_route_deleteData:
	byte 0x; dup // push empty bytes to fill the stack frame for this subroutine's local variables

	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute deleteData(uint64,address)void
	callsub deleteData
	int 1
	return

deleteData:
	proto 4 0

	// contracts/algo-did.algo.ts:145
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:147
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: address
	frame_bury -3 // storage key//metadata

	// contracts/algo-did.algo.ts:148
	// assert(metadata.status === DELETING)
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 16 1
	byte 0x0000000000000002
	b==
	assert

	// contracts/algo-did.algo.ts:149
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 0 8
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz skip_and1
	frame_dig -2 // boxIndex: uint64
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 8 8
	btoi
	<=
	&&

skip_and1:
	assert

	// if1_condition
	// contracts/algo-did.algo.ts:151
	// boxIndex !== metadata.start
	frame_dig -2 // boxIndex: uint64
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 0 8
	btoi
	!=
	bz if1_end

	// if1_consequent
	// contracts/algo-did.algo.ts:151
	// assert(metadata.lastDeleted === boxIndex - 1)
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 25 8
	btoi
	frame_dig -2 // boxIndex: uint64
	int 1
	-
	==
	assert

if1_end:
	// contracts/algo-did.algo.ts:153
	// preMBR = globals.currentApplicationAddress.minBalance
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	assert
	frame_bury -4 // preMBR: uint64

	// contracts/algo-did.algo.ts:155
	// this.dataBoxes(boxIndex).delete()
	frame_dig -2 // boxIndex: uint64
	itob
	box_del

	// if2_condition
	// contracts/algo-did.algo.ts:157
	// boxIndex === metadata.end
	frame_dig -2 // boxIndex: uint64
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 8 8
	btoi
	==
	bz if2_else

	// if2_consequent
	// contracts/algo-did.algo.ts:157
	// this.metadata(pubKey).delete()
	frame_dig -1 // pubKey: address
	box_del
	b if2_end

if2_else:
	// contracts/algo-did.algo.ts:158
	// metadata.lastDeleted = boxIndex
	frame_dig -3 // storage key//metadata
	box_get
	assert
	frame_dig -2 // boxIndex: uint64
	itob
	replace2 25
	frame_dig -3 // storage key//metadata
	swap
	box_put

if2_end:
	// contracts/algo-did.algo.ts:160
	// sendPayment({
	//       amount: preMBR - globals.currentApplicationAddress.minBalance,
	//       receiver: this.txn.sender,
	//     })
	itxn_begin
	int pay
	itxn_field TypeEnum

	// contracts/algo-did.algo.ts:161
	// amount: preMBR - globals.currentApplicationAddress.minBalance
	frame_dig -4 // preMBR: uint64
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	assert
	-
	itxn_field Amount

	// contracts/algo-did.algo.ts:162
	// receiver: this.txn.sender
	txn Sender
	itxn_field Receiver

	// Fee field not set, defaulting to 0
	int 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// updateApplication()void
//
// Allow the contract to be updated by the creator
abi_route_updateApplication:
	// execute updateApplication()void
	callsub updateApplication
	int 1
	return

updateApplication:
	proto 0 0

	// contracts/algo-did.algo.ts:170
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert
	retsub

// dummy()void
//
// Dummy function to add extra box references for deleteData.
// Boxes are 32k, but a single app call can only inlcude enough references to read/write 8k
// at a time. Thus when a box is deleted, we need to add additional dummy calls with box
// references to increase the total read/write budget to 32k.
abi_route_dummy:
	// execute dummy()void
	callsub dummy
	int 1
	return

dummy:
	proto 0 0
	retsub

abi_route_createApplication:
	int 1
	return

create_NoOp:
	method "createApplication()void"
	txna ApplicationArgs 0
	match abi_route_createApplication
	err

call_NoOp:
	method "startUpload(address,uint64,uint64,pay)void"
	method "upload(address,uint64,uint64,byte[])void"
	method "finishUpload(address)void"
	method "startDelete(address)void"
	method "deleteData(address,uint64)void"
	method "dummy()void"
	txna ApplicationArgs 0
	match abi_route_startUpload abi_route_upload abi_route_finishUpload abi_route_startDelete abi_route_deleteData abi_route_dummy
	err

call_UpdateApplication:
	method "updateApplication()void"
	txna ApplicationArgs 0
	match abi_route_updateApplication
	err", - "clear": "I3ByYWdtYSB2ZXJzaW9uIDkKaW50IDE=" - }, - "contract": { - "name": "AlgoDID", - "desc": "", - "methods": [ - { - "name": "startUpload", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The pubkey of the DID" - }, - { - "name": "numBoxes", - "type": "uint64", - "desc": "The number of boxes that the data will take up" - }, - { - "name": "endBoxSize", - "type": "uint64", - "desc": "The size of the last box" - }, - { - "name": "mbrPayment", - "type": "pay", - "desc": "Payment from the uploader to cover the box MBR" - } - ], - "desc": "Allocate boxes to begin data upload process", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "upload", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The pubkey of the DID" - }, - { - "name": "boxIndex", - "type": "uint64", - "desc": "The index of the box to upload the given chunk of data to" - }, - { - "name": "offset", - "type": "uint64", - "desc": "The offset within the box to start writing the data" - }, - { - "name": "data", - "type": "byte[]", - "desc": "The data to write" - } - ], - "desc": "Upload data to a specific offset in a box", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "finishUpload", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The address of the DID" - } - ], - "desc": "Mark uploading as false", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "startDelete", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The address of the DID" - } - ], - "desc": "Starts the deletion process for the data associated with a DID", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "deleteData", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The address of the DID" - }, - { - "name": "boxIndex", - "type": "uint64", - "desc": "The index of the box to delete" - } - ], - "desc": "Deletes a box of data", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "updateApplication", - "args": [], - "desc": "Allow the contract to be updated by the creator", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "dummy", - "args": [], - "desc": "Dummy function to add extra box references for deleteData.Boxes are 32k, but a single app call can only inlcude enough references to read/write 8kat a time. Thus when a box is deleted, we need to add additional dummy calls with boxreferences to increase the total read/write budget to 32k.", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "createApplication", - "desc": "", - "returns": { - "type": "void", - "desc": "" - }, - "args": [] - } - ] - } -} \ No newline at end of file diff --git a/reference_contract/AlgoDID.arc4.json b/reference_contract/AlgoDID.arc4.json deleted file mode 100644 index a62273e..0000000 --- a/reference_contract/AlgoDID.arc4.json +++ /dev/null @@ -1,143 +0,0 @@ -{ - "name": "AlgoDID", - "desc": "", - "methods": [ - { - "name": "startUpload", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The pubkey of the DID" - }, - { - "name": "numBoxes", - "type": "uint64", - "desc": "The number of boxes that the data will take up" - }, - { - "name": "endBoxSize", - "type": "uint64", - "desc": "The size of the last box" - }, - { - "name": "mbrPayment", - "type": "pay", - "desc": "Payment from the uploader to cover the box MBR" - } - ], - "desc": "Allocate boxes to begin data upload process", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "upload", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The pubkey of the DID" - }, - { - "name": "boxIndex", - "type": "uint64", - "desc": "The index of the box to upload the given chunk of data to" - }, - { - "name": "offset", - "type": "uint64", - "desc": "The offset within the box to start writing the data" - }, - { - "name": "data", - "type": "byte[]", - "desc": "The data to write" - } - ], - "desc": "Upload data to a specific offset in a box", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "finishUpload", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The address of the DID" - } - ], - "desc": "Mark uploading as false", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "startDelete", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The address of the DID" - } - ], - "desc": "Starts the deletion process for the data associated with a DID", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "deleteData", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The address of the DID" - }, - { - "name": "boxIndex", - "type": "uint64", - "desc": "The index of the box to delete" - } - ], - "desc": "Deletes a box of data", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "updateApplication", - "args": [], - "desc": "Allow the contract to be updated by the creator", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "dummy", - "args": [], - "desc": "Dummy function to add extra box references for deleteData.Boxes are 32k, but a single app call can only inlcude enough references to read/write 8kat a time. Thus when a box is deleted, we need to add additional dummy calls with boxreferences to increase the total read/write budget to 32k.", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "createApplication", - "desc": "", - "returns": { - "type": "void", - "desc": "" - }, - "args": [] - } - ] -} \ No newline at end of file diff --git a/reference_contract/README.md b/reference_contract/README.md deleted file mode 100644 index fb06c5d..0000000 --- a/reference_contract/README.md +++ /dev/null @@ -1,7 +0,0 @@ -# Reference Contract - -This is the reference implementation of the contract that will be used to store the DIDDocuments for `did:algo`. This is the contract that is used by the CLI tool by default when deploying a new contract. - -It should be noted that the `did:algo` spec will work with any contract that implements the ABI interface defined in [the ARC4 JSON description](./AlgDID.arc4.json) and the `did:algo` [spec](../SPEC.md). - -The client-side code for interacting with this contract can be seen [here](../client/internal/main.go). diff --git a/reference_contract/__test__/DIDocument.json b/reference_contract/__test__/DIDocument.json new file mode 100644 index 0000000..9f179e9 --- /dev/null +++ b/reference_contract/__test__/DIDocument.json @@ -0,0 +1,93 @@ +{ + "@context": [ + "https://www.w3.org/ns/did/v1", + "https://w3id.org/security/suites/jws-2020/v1" + ], + "verificationMethod": [ + { + "id": "did:example:123#key-0", + "type": "JsonWebKey2020", + "controller": "did:example:123", + "publicKeyJwk": { + "kty": "OKP", + "crv": "Ed25519", + "x": "VCpo2LMLhn6iWku8MKvSLg2ZAoC-nlOyPVQaO3FxVeQ" + } + }, + { + "id": "did:example:123#key-1", + "type": "JsonWebKey2020", + "controller": "did:example:123", + "publicKeyJwk": { + "kty": "OKP", + "crv": "X25519", + "x": "pE_mG098rdQjY3MKK2D5SUQ6ZOEW3a6Z6T7Z4SgnzCE" + } + }, + { + "id": "did:example:123#key-2", + "type": "JsonWebKey2020", + "controller": "did:example:123", + "publicKeyJwk": { + "kty": "EC", + "crv": "secp256k1", + "x": "Z4Y3NNOxv0J6tCgqOBFnHnaZhJF6LdulT7z8A-2D5_8", + "y": "i5a2NtJoUKXkLm6q8nOEu9WOkso1Ag6FTUT6k_LMnGk" + } + }, + { + "id": "did:example:123#key-3", + "type": "JsonWebKey2020", + "controller": "did:example:123", + "publicKeyJwk": { + "kty": "EC", + "crv": "secp256k1", + "x": "U1V4TVZVMUpUa0ZVU1NBcU9CRm5IbmFaaEpGNkxkdWx", + "y": "i5a2NtJoUKXkLm6q8nOEu9WOkso1Ag6FTUT6k_LMnGk" + } + }, + { + "id": "did:example:123#key-4", + "type": "JsonWebKey2020", + "controller": "did:example:123", + "publicKeyJwk": { + "kty": "EC", + "crv": "P-256", + "x": "Ums5WVgwRkRTVVFnU3k5c2xvZllMbEcwM3NPRW91ZzN", + "y": "nDQW6XZ7b_u2Sy9slofYLlG03sOEoug3I0aAPQ0exs4" + } + }, + { + "id": "did:example:123#key-5", + "type": "JsonWebKey2020", + "controller": "did:example:123", + "publicKeyJwk": { + "kty": "EC", + "crv": "P-384", + "x": "VUZKSlUwMGdpSXplekRwODhzX2N4U1BYdHVYWUZsaXVDR25kZ1U0UXA4bDkxeHpE", + "y": "jq4QoAHKiIzezDp88s_cxSPXtuXYFliuCGndgU4Qp8l91xzD1spCmFIzQgVjqvcP" + } + }, + { + "id": "did:example:123#key-6", + "type": "JsonWebKey2020", + "controller": "did:example:123", + "publicKeyJwk": { + "kty": "EC", + "crv": "P-521", + "x": "VTI5c1lYSmZWMmx1WkhNZ0dQTXhaYkhtSnBEU3UtSXZwdUtpZ0VOMnB6Z1d0U28tLVJ3ZC1uNzhuclduWnplRGMx", + "y": "UW5WNVgwSnBkR052YVc0Z1VqY1B6LVpoZWNaRnliT3FMSUpqVk9sTEVUSDd1UGx5RzBnRW9NV25JWlhoUVZ5cFB5" + } + }, + { + "id": "did:example:123#key-7", + "type": "JsonWebKey2020", + "controller": "did:example:123", + "publicKeyJwk": { + "kty": "RSA", + "e": "AQAB", + "n": "UkhWaGJGOUZRMTlFVWtKSElBdENGV2hlU1F2djFNRXh1NVJMQ01UNGpWazlraEpLdjhKZU1YV2UzYldIYXRqUHNrZGYyZGxhR2tXNVFqdE9uVUtMNzQybXZyNHRDbGRLUzNVTElhVDFoSkluTUhIeGoyZ2N1Yk82ZUVlZ0FDUTRRU3U5TE8wSC1MTV9MM0RzUkFCQjdRamE4SGVjcHl1c3BXMVR1X0RicXhjU253ZW5kYW13TDUyVjE3ZUtobE80dVh3djJIRmx4dWZGSE0wS21DSnVqSUt5QXhqRF9tM3FfX0lpSFVWSEQxdERJRXZMUGhHOUF6c24zajk1ZC1zYU" + } + } + ] + } \ No newline at end of file diff --git a/reference_contract/__test__/TEAL.pdf b/reference_contract/__test__/TEAL.pdf new file mode 100644 index 0000000000000000000000000000000000000000..eb56c4a4cd4e9de15bce6c6428873a38d4b2dd92 GIT binary patch literal 304979 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

}>*VZGhKXA+ZU6+aV?Q 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 T!!*9yGI>px4so=%pGB|+E~tB=Jw73LI{P7I4q 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 uiBfw?Ub_} { + /** + * Large data (> 32k) to simulate a large DID Document + * that needs to be put into multiple boxes + */ + const bigData = fs.readFileSync(`${__dirname}/TEAL.pdf`); + + /** + * Small data (< 32k) to simulate a small DID Document + * that can fit into a single box + */ + const smallJSONObject = { keyOne: 'foo', keyTwo: 'bar' }; + + /** The public key for the user in the tests that has a big DID Document */ + const bigDataUserKey = algosdk.decodeAddress(algosdk.generateAccount().addr).publicKey; + + /** The public key for the user in the tests that has a small DID Document */ + const smallDataUserKey = algosdk.decodeAddress(algosdk.generateAccount().addr).publicKey; + + /** The public key for the user in the tests that updates their DID Document */ + const updateDataUserKey = algosdk.decodeAddress(algosdk.generateAccount().addr).publicKey; + + /** algokti appClient for interacting with the contract */ + let appClient: ApplicationClient; + + /** The account that will be used to create and call the contract */ + let sender: algosdk.Account; + + /** The ID of the contract */ + let appId: number; + + beforeAll(async () => { + sender = await algokit.getDispenserAccount(algodClient, kmdClient); + + appClient = new ApplicationClient({ + resolveBy: 'id', + id: 0, + sender, + app: JSON.stringify(appSpec), + }, algodClient); + + await appClient.create({ method: 'createApplication', methodArgs: [], sendParams: { suppressLog: true } }); + + await appClient.fundAppAccount({ + amount: algokit.microAlgos(100_000), + sendParams: { suppressLog: true }, + }); + + appId = Number((await appClient.getAppReference()).appId); + }); + + describe('uploadDIDDocument and Resolve', () => { + it('(LARGE) DIDocument upload and resolve', async () => { + const { appId } = await appClient.getAppReference(); + const addr = algosdk.encodeAddress(bigDataUserKey); + + // Large upload + await uploadDIDDocument(bigData, Number(appId), bigDataUserKey, sender, algodClient); + + // Reconstruct DID from several boxes + const resolvedData: Buffer = await resolveDID(`did:algo:${addr}-${appId}`, algodClient); + expect(resolvedData.toString('hex')).toEqual(bigData.toString('hex')) + }) + + it('(SMALL) DIDocument upload and resolve', async () => { + const { appId } = await appClient.getAppReference(); + const addr = algosdk.encodeAddress(smallDataUserKey); + + // Small upload + await uploadDIDDocument(Buffer.from(JSON.stringify(smallJSONObject)), + Number(appId), + smallDataUserKey, + sender, + algodClient); + + // Reconstruct DID from several boxes + const resolvedData: Buffer = await resolveDID(`did:algo:${addr}-${appId}`, algodClient); + expect(resolvedData.toString('hex')).toEqual(Buffer.from(JSON.stringify(smallJSONObject)).toString('hex')) + }) + }) + + describe('deleteDIDDocument', () => { + const deleteDIDDocumentTest = async (userKey: Uint8Array) => { + await deleteDIDDocument(appId, userKey, sender, algodClient); + + const addr = algosdk.encodeAddress(userKey); + await expect(resolveDID(`did:algo:${addr}-${appId}`, algodClient)).rejects.toThrow(); + }; + + it('deletes big (multi-box) data', async () => { + await deleteDIDDocumentTest(bigDataUserKey); + }); + + it('deletes small (single-box) data', async () => { + await deleteDIDDocumentTest(smallDataUserKey); + }); + + it('returns MBR', async () => { + const { appAddress } = await appClient.getAppReference(); + const appAmount = (await algodClient.accountInformation(appAddress).do()).amount; + + expect(appAmount).toBe(100_000); + }); + }); + + describe('updateDocument', () => { + beforeAll(async () => { + // Initially upload the big data as the DID Document + await uploadDIDDocument( + bigData, + appId, + updateDataUserKey, + sender, + algodClient, + ); + }); + + it('uploads and resolves new data', async () => { + // Update the DID Document to be the small data + const data = Buffer.from(JSON.stringify(smallJSONObject)); + await updateDIDDocument( + data, + appId, + updateDataUserKey, + sender, + algodClient, + ); + + const addr = algosdk.encodeAddress(updateDataUserKey); + const resolvedData = await resolveDID(`did:algo:${addr}-${appId}`, algodClient); + + expect(resolvedData.toString()).toEqual(JSON.stringify(smallJSONObject)); + }); + }); +}); diff --git a/reference_contract/__test__/common.ts b/reference_contract/__test__/common.ts new file mode 100644 index 0000000..aeb4955 --- /dev/null +++ b/reference_contract/__test__/common.ts @@ -0,0 +1,6 @@ +/* eslint-disable func-names */ +import algosdk from 'algosdk'; + +export const indexerClient = new algosdk.Indexer('a'.repeat(64), 'http://localhost', 8980); +export const algodClient = new algosdk.Algodv2('a'.repeat(64), 'http://localhost', 4001); +export const kmdClient = new algosdk.Kmd('a'.repeat(64), 'http://localhost', 4002); diff --git a/reference_contract/algo-did.algo.ts b/reference_contract/contracts/algo-did.algo.ts similarity index 100% rename from reference_contract/algo-did.algo.ts rename to reference_contract/contracts/algo-did.algo.ts diff --git a/reference_contract/contracts/clients/AlgoDIDClient.ts b/reference_contract/contracts/clients/AlgoDIDClient.ts new file mode 100644 index 0000000..e002a7c --- /dev/null +++ b/reference_contract/contracts/clients/AlgoDIDClient.ts @@ -0,0 +1,1047 @@ +/* eslint-disable */ +/** + * This file was automatically generated by @algorandfoundation/algokit-client-generator. + * DO NOT MODIFY IT BY HAND. + * requires: @algorandfoundation/algokit-utils: ^2 + */ +import * as algokit from '@algorandfoundation/algokit-utils' +import { + AppCallTransactionResult, + AppCallTransactionResultOfType, + CoreAppCallArgs, + RawAppCallArgs, + AppState, + TealTemplateParams, + ABIAppCallArg, +} from '@algorandfoundation/algokit-utils/types/app' +import { + AppClientCallCoreParams, + AppClientCompilationParams, + AppClientDeployCoreParams, + AppDetails, + ApplicationClient, +} from '@algorandfoundation/algokit-utils/types/app-client' +import { AppSpec } from '@algorandfoundation/algokit-utils/types/app-spec' +import { SendTransactionResult, TransactionToSign, SendTransactionFrom } from '@algorandfoundation/algokit-utils/types/transaction' +import { Algodv2, OnApplicationComplete, Transaction, TransactionWithSigner, AtomicTransactionComposer } from 'algosdk' +export const APP_SPEC: AppSpec = { + "hints": { + "startUpload(address,uint64,uint64,pay)void": { + "call_config": { + "no_op": "CALL" + } + }, + "upload(address,uint64,uint64,byte[])void": { + "call_config": { + "no_op": "CALL" + } + }, + "finishUpload(address)void": { + "call_config": { + "no_op": "CALL" + } + }, + "startDelete(address)void": { + "call_config": { + "no_op": "CALL" + } + }, + "deleteData(address,uint64)void": { + "call_config": { + "no_op": "CALL" + } + }, + "updateApplication()void": { + "call_config": { + "update_application": "CALL" + } + }, + "dummy()void": { + "call_config": { + "no_op": "CALL" + } + }, + "createApplication()void": { + "call_config": { + "no_op": "CREATE" + } + } + }, + "bare_call_config": { + "no_op": "NEVER", + "opt_in": "NEVER", + "close_out": "NEVER", + "update_application": "NEVER", + "delete_application": "NEVER" + }, + "schema": { + "local": { + "declared": {}, + "reserved": {} + }, + "global": { + "declared": { + "currentIndex": { + "type": "uint64", + "key": "currentIndex" + } + }, + "reserved": {} + } + }, + "state": { + "global": { + "num_byte_slices": 0, + "num_uints": 1 + }, + "local": { + "num_byte_slices": 0, + "num_uints": 0 + } + }, + "source": { + "approval": "#pragma version 9

// This TEAL was generated by TEALScript v0.51.1
// https://github.com/algorand-devrel/TEALScript

// This contract is compliant with and/or implements the following ARCs: [ ARC4 ]

// The following ten lines of TEAL handle initial program flow
// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed
// Here, action refers to the OnComplete in combination with whether the app is being created or called
// Every possible action for this contract is represented in the switch statement
// If the action is not implmented in the contract, its repsective branch will be "NOT_IMPLMENTED" which just contains "err"
txn ApplicationID
int 0
>
int 6
*
txn OnCompletion
+
switch create_NoOp NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED call_NoOp NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED call_UpdateApplication

NOT_IMPLEMENTED:
	err

// startUpload(pay,uint64,uint64,address)void
//
// 
// Allocate boxes to begin data upload process
// 
// @param pubKey The pubkey of the DID
// @param numBoxes The number of boxes that the data will take up
// @param endBoxSize The size of the last box
// @param mbrPayment Payment from the uploader to cover the box MBR
abi_route_startUpload:
	byte 0x; dupn 3 // push empty bytes to fill the stack frame for this subroutine's local variables

	// mbrPayment: pay
	txn GroupIndex
	int 1
	-
	dup
	gtxns TypeEnum
	int pay
	==
	assert

	// endBoxSize: uint64
	txna ApplicationArgs 3
	btoi

	// numBoxes: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute startUpload(pay,uint64,uint64,address)void
	callsub startUpload
	int 1
	return

startUpload:
	proto 8 0

	// contracts/algo-did.algo.ts:64
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:66
	// startBox = this.currentIndex.value
	byte 0x63757272656e74496e646578 // "currentIndex"
	app_global_get
	frame_bury -5 // startBox: uint64

	// contracts/algo-did.algo.ts:67
	// endBox = startBox + numBoxes - 1
	frame_dig -5 // startBox: uint64
	frame_dig -2 // numBoxes: uint64
	+
	int 1
	-
	frame_bury -6 // endBox: uint64

	// contracts/algo-did.algo.ts:69
	// metadata: Metadata = {
	//       start: startBox, end: endBox, status: UPLOADING, endSize: endBoxSize, lastDeleted: 0,
	//     }
	frame_dig -5 // startBox: uint64
	itob
	frame_dig -6 // endBox: uint64
	itob
	concat
	byte 0x00
	byte 0x00
	bitlen
	int 8
	<=
	assert
	byte 0xFF
	b&
	concat
	frame_dig -3 // endBoxSize: uint64
	itob
	concat
	byte 0x0000000000000000
	concat
	frame_bury -7 // metadata: Metadata

	// contracts/algo-did.algo.ts:73
	// assert(!this.metadata(pubKey).exists)
	frame_dig -1 // pubKey: address
	box_len
	swap
	pop
	!
	assert

	// contracts/algo-did.algo.ts:75
	// this.metadata(pubKey).value = metadata
	frame_dig -1 // pubKey: address
	frame_dig -7 // metadata: Metadata
	box_put

	// contracts/algo-did.algo.ts:77
	// this.currentIndex.value = endBox + 1
	byte 0x63757272656e74496e646578 // "currentIndex"
	frame_dig -6 // endBox: uint64
	int 1
	+
	app_global_put

	// contracts/algo-did.algo.ts:79
	// totalCost = numBoxes * COST_PER_BOX // cost of data boxes
	//     + (numBoxes - 1) * MAX_BOX_SIZE * COST_PER_BYTE // cost of data
	//     + numBoxes * 8 * COST_PER_BYTE // cost of data keys
	//     + endBoxSize * COST_PER_BYTE // cost of last data box
	//     + COST_PER_BOX + (8 + 8 + 1 + 8 + 32 + 8) * COST_PER_BYTE
	frame_dig -2 // numBoxes: uint64
	int 2500
	*
	frame_dig -2 // numBoxes: uint64
	int 1
	-
	int 32768
	*
	int 400
	*
	+
	frame_dig -2 // numBoxes: uint64
	int 8
	*
	int 400
	*
	+
	frame_dig -3 // endBoxSize: uint64
	int 400
	*
	+
	int 2500
	+
	int 26000
	+
	frame_bury -8 // totalCost: uint64

	// contracts/algo-did.algo.ts:85
	// assert(mbrPayment.amount === totalCost)
	frame_dig -4 // mbrPayment: pay
	gtxns Amount
	frame_dig -8 // totalCost: uint64
	==
	assert

	// contracts/algo-did.algo.ts:86
	// assert(mbrPayment.receiver === this.app.address)
	frame_dig -4 // mbrPayment: pay
	gtxns Receiver
	global CurrentApplicationAddress
	==
	assert
	retsub

// upload(bytes,uint64,uint64,address)void
//
// 
// Upload data to a specific offset in a box
// 
// @param pubKey The pubkey of the DID
// @param boxIndex The index of the box to upload the given chunk of data to
// @param offset The offset within the box to start writing the data
// @param data The data to write
abi_route_upload:
	byte 0x // push empty bytes to fill the stack frame for this subroutine's local variables

	// data: byte[]
	txna ApplicationArgs 4
	extract 2 0

	// offset: uint64
	txna ApplicationArgs 3
	btoi

	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute upload(bytes,uint64,uint64,address)void
	callsub upload
	int 1
	return

upload:
	proto 5 0

	// contracts/algo-did.algo.ts:99
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:101
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: address
	frame_bury -5 // storage key//metadata

	// contracts/algo-did.algo.ts:102
	// assert(metadata.status === UPLOADING)
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 16 1
	byte 0x0000000000000000
	b==
	assert

	// contracts/algo-did.algo.ts:103
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 0 8
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz skip_and0
	frame_dig -2 // boxIndex: uint64
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 8 8
	btoi
	<=
	&&

skip_and0:
	assert

	// if0_condition
	// contracts/algo-did.algo.ts:105
	// offset === 0
	frame_dig -3 // offset: uint64
	int 0
	==
	bz if0_end

	// if0_consequent
	// contracts/algo-did.algo.ts:106
	// this.dataBoxes(boxIndex).create(boxIndex === metadata.end ? metadata.endSize : MAX_BOX_SIZE)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -2 // boxIndex: uint64
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 8 8
	btoi
	==
	bz ternary0_false
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 17 8
	btoi
	b ternary0_end

ternary0_false:
	int 32768

ternary0_end:
	box_create

if0_end:
	// contracts/algo-did.algo.ts:109
	// this.dataBoxes(boxIndex).replace(offset, data)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -3 // offset: uint64
	frame_dig -4 // data: bytes
	box_replace
	retsub

// finishUpload(address)void
//
// 
// Mark uploading as false
// 
// @param pubKey The address of the DID
abi_route_finishUpload:
	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute finishUpload(address)void
	callsub finishUpload
	int 1
	return

finishUpload:
	proto 1 0

	// contracts/algo-did.algo.ts:119
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:121
	// this.metadata(pubKey).value.status = READY
	frame_dig -1 // pubKey: address
	int 16
	byte 0x01
	box_replace
	retsub

// startDelete(address)void
//
// Starts the deletion process for the data associated with a DID
// 
// @param pubKey The address of the DID
abi_route_startDelete:
	byte 0x // push empty bytes to fill the stack frame for this subroutine's local variables

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute startDelete(address)void
	callsub startDelete
	int 1
	return

startDelete:
	proto 2 0

	// contracts/algo-did.algo.ts:130
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:132
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: address
	frame_bury -2 // storage key//metadata

	// contracts/algo-did.algo.ts:133
	// assert(metadata.status === READY)
	frame_dig -2 // storage key//metadata
	box_get
	assert
	extract 16 1
	byte 0x0000000000000001
	b==
	assert

	// contracts/algo-did.algo.ts:135
	// metadata.status = DELETING
	frame_dig -2 // storage key//metadata
	box_get
	assert
	byte 0x02
	replace2 16
	frame_dig -2 // storage key//metadata
	swap
	box_put
	retsub

// deleteData(uint64,address)void
//
// Deletes a box of data
// 
// @param pubKey The address of the DID
// @param boxIndex The index of the box to delete
abi_route_deleteData:
	byte 0x; dup // push empty bytes to fill the stack frame for this subroutine's local variables

	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute deleteData(uint64,address)void
	callsub deleteData
	int 1
	return

deleteData:
	proto 4 0

	// contracts/algo-did.algo.ts:145
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:147
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: address
	frame_bury -3 // storage key//metadata

	// contracts/algo-did.algo.ts:148
	// assert(metadata.status === DELETING)
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 16 1
	byte 0x0000000000000002
	b==
	assert

	// contracts/algo-did.algo.ts:149
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 0 8
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz skip_and1
	frame_dig -2 // boxIndex: uint64
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 8 8
	btoi
	<=
	&&

skip_and1:
	assert

	// if1_condition
	// contracts/algo-did.algo.ts:151
	// boxIndex !== metadata.start
	frame_dig -2 // boxIndex: uint64
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 0 8
	btoi
	!=
	bz if1_end

	// if1_consequent
	// contracts/algo-did.algo.ts:151
	// assert(metadata.lastDeleted === boxIndex - 1)
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 25 8
	btoi
	frame_dig -2 // boxIndex: uint64
	int 1
	-
	==
	assert

if1_end:
	// contracts/algo-did.algo.ts:153
	// preMBR = globals.currentApplicationAddress.minBalance
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	assert
	frame_bury -4 // preMBR: uint64

	// contracts/algo-did.algo.ts:155
	// this.dataBoxes(boxIndex).delete()
	frame_dig -2 // boxIndex: uint64
	itob
	box_del

	// if2_condition
	// contracts/algo-did.algo.ts:157
	// boxIndex === metadata.end
	frame_dig -2 // boxIndex: uint64
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 8 8
	btoi
	==
	bz if2_else

	// if2_consequent
	// contracts/algo-did.algo.ts:157
	// this.metadata(pubKey).delete()
	frame_dig -1 // pubKey: address
	box_del
	b if2_end

if2_else:
	// contracts/algo-did.algo.ts:158
	// metadata.lastDeleted = boxIndex
	frame_dig -3 // storage key//metadata
	box_get
	assert
	frame_dig -2 // boxIndex: uint64
	itob
	replace2 25
	frame_dig -3 // storage key//metadata
	swap
	box_put

if2_end:
	// contracts/algo-did.algo.ts:160
	// sendPayment({
	//       amount: preMBR - globals.currentApplicationAddress.minBalance,
	//       receiver: this.txn.sender,
	//     })
	itxn_begin
	int pay
	itxn_field TypeEnum

	// contracts/algo-did.algo.ts:161
	// amount: preMBR - globals.currentApplicationAddress.minBalance
	frame_dig -4 // preMBR: uint64
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	assert
	-
	itxn_field Amount

	// contracts/algo-did.algo.ts:162
	// receiver: this.txn.sender
	txn Sender
	itxn_field Receiver

	// Fee field not set, defaulting to 0
	int 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// updateApplication()void
//
// Allow the contract to be updated by the creator
abi_route_updateApplication:
	// execute updateApplication()void
	callsub updateApplication
	int 1
	return

updateApplication:
	proto 0 0

	// contracts/algo-did.algo.ts:170
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert
	retsub

// dummy()void
//
// Dummy function to add extra box references for deleteData.
// Boxes are 32k, but a single app call can only inlcude enough references to read/write 8k
// at a time. Thus when a box is deleted, we need to add additional dummy calls with box
// references to increase the total read/write budget to 32k.
abi_route_dummy:
	// execute dummy()void
	callsub dummy
	int 1
	return

dummy:
	proto 0 0
	retsub

abi_route_createApplication:
	int 1
	return

create_NoOp:
	method "createApplication()void"
	txna ApplicationArgs 0
	match abi_route_createApplication
	err

call_NoOp:
	method "startUpload(address,uint64,uint64,pay)void"
	method "upload(address,uint64,uint64,byte[])void"
	method "finishUpload(address)void"
	method "startDelete(address)void"
	method "deleteData(address,uint64)void"
	method "dummy()void"
	txna ApplicationArgs 0
	match abi_route_startUpload abi_route_upload abi_route_finishUpload abi_route_startDelete abi_route_deleteData abi_route_dummy
	err

call_UpdateApplication:
	method "updateApplication()void"
	txna ApplicationArgs 0
	match abi_route_updateApplication
	err", + "clear": "I3ByYWdtYSB2ZXJzaW9uIDkKaW50IDE=" + }, + "contract": { + "name": "AlgoDID", + "desc": "", + "methods": [ + { + "name": "startUpload", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The pubkey of the DID" + }, + { + "name": "numBoxes", + "type": "uint64", + "desc": "The number of boxes that the data will take up" + }, + { + "name": "endBoxSize", + "type": "uint64", + "desc": "The size of the last box" + }, + { + "name": "mbrPayment", + "type": "pay", + "desc": "Payment from the uploader to cover the box MBR" + } + ], + "desc": "Allocate boxes to begin data upload process", + "returns": { + "type": "void", + "desc": "" + } + }, + { + "name": "upload", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The pubkey of the DID" + }, + { + "name": "boxIndex", + "type": "uint64", + "desc": "The index of the box to upload the given chunk of data to" + }, + { + "name": "offset", + "type": "uint64", + "desc": "The offset within the box to start writing the data" + }, + { + "name": "data", + "type": "byte[]", + "desc": "The data to write" + } + ], + "desc": "Upload data to a specific offset in a box", + "returns": { + "type": "void", + "desc": "" + } + }, + { + "name": "finishUpload", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + } + ], + "desc": "Mark uploading as false", + "returns": { + "type": "void", + "desc": "" + } + }, + { + "name": "startDelete", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + } + ], + "desc": "Starts the deletion process for the data associated with a DID", + "returns": { + "type": "void", + "desc": "" + } + }, + { + "name": "deleteData", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + }, + { + "name": "boxIndex", + "type": "uint64", + "desc": "The index of the box to delete" + } + ], + "desc": "Deletes a box of data", + "returns": { + "type": "void", + "desc": "" + } + }, + { + "name": "updateApplication", + "args": [], + "desc": "Allow the contract to be updated by the creator", + "returns": { + "type": "void", + "desc": "" + } + }, + { + "name": "dummy", + "args": [], + "desc": "Dummy function to add extra box references for deleteData.Boxes are 32k, but a single app call can only inlcude enough references to read/write 8kat a time. Thus when a box is deleted, we need to add additional dummy calls with boxreferences to increase the total read/write budget to 32k.", + "returns": { + "type": "void", + "desc": "" + } + }, + { + "name": "createApplication", + "desc": "", + "returns": { + "type": "void", + "desc": "" + }, + "args": [] + } + ] + } +} + +/** + * Defines an onCompletionAction of 'no_op' + */ +export type OnCompleteNoOp = { onCompleteAction?: 'no_op' | OnApplicationComplete.NoOpOC } +/** + * Defines an onCompletionAction of 'opt_in' + */ +export type OnCompleteOptIn = { onCompleteAction: 'opt_in' | OnApplicationComplete.OptInOC } +/** + * Defines an onCompletionAction of 'close_out' + */ +export type OnCompleteCloseOut = { onCompleteAction: 'close_out' | OnApplicationComplete.CloseOutOC } +/** + * Defines an onCompletionAction of 'delete_application' + */ +export type OnCompleteDelApp = { onCompleteAction: 'delete_application' | OnApplicationComplete.DeleteApplicationOC } +/** + * Defines an onCompletionAction of 'update_application' + */ +export type OnCompleteUpdApp = { onCompleteAction: 'update_application' | OnApplicationComplete.UpdateApplicationOC } +/** + * A state record containing a single unsigned integer + */ +export type IntegerState = { + /** + * Gets the state value as a BigInt + */ + asBigInt(): bigint + /** + * Gets the state value as a number. + */ + asNumber(): number +} +/** + * A state record containing binary data + */ +export type BinaryState = { + /** + * Gets the state value as a Uint8Array + */ + asByteArray(): Uint8Array + /** + * Gets the state value as a string + */ + asString(): string +} + +/** + * Defines the types of available calls and state of the AlgoDid smart contract. + */ +export type AlgoDid = { + /** + * Maps method signatures / names to their argument and return types. + */ + methods: + & Record<'startUpload(address,uint64,uint64,pay)void' | 'startUpload', { + argsObj: { + /** + * The pubkey of the DID + */ + pubKey: string + /** + * The number of boxes that the data will take up + */ + numBoxes: bigint | number + /** + * The size of the last box + */ + endBoxSize: bigint | number + /** + * Payment from the uploader to cover the box MBR + */ + mbrPayment: TransactionToSign | Transaction | Promise + } + argsTuple: [pubKey: string, numBoxes: bigint | number, endBoxSize: bigint | number, mbrPayment: TransactionToSign | Transaction | Promise] + returns: void + }> + & Record<'upload(address,uint64,uint64,byte[])void' | 'upload', { + argsObj: { + /** + * The pubkey of the DID + */ + pubKey: string + /** + * The index of the box to upload the given chunk of data to + */ + boxIndex: bigint | number + /** + * The offset within the box to start writing the data + */ + offset: bigint | number + /** + * The data to write + */ + data: Uint8Array + } + argsTuple: [pubKey: string, boxIndex: bigint | number, offset: bigint | number, data: Uint8Array] + returns: void + }> + & Record<'finishUpload(address)void' | 'finishUpload', { + argsObj: { + /** + * The address of the DID + */ + pubKey: string + } + argsTuple: [pubKey: string] + returns: void + }> + & Record<'startDelete(address)void' | 'startDelete', { + argsObj: { + /** + * The address of the DID + */ + pubKey: string + } + argsTuple: [pubKey: string] + returns: void + }> + & Record<'deleteData(address,uint64)void' | 'deleteData', { + argsObj: { + /** + * The address of the DID + */ + pubKey: string + /** + * The index of the box to delete + */ + boxIndex: bigint | number + } + argsTuple: [pubKey: string, boxIndex: bigint | number] + returns: void + }> + & Record<'updateApplication()void' | 'updateApplication', { + argsObj: { + } + argsTuple: [] + returns: void + }> + & Record<'dummy()void' | 'dummy', { + argsObj: { + } + argsTuple: [] + returns: void + }> + & Record<'createApplication()void' | 'createApplication', { + argsObj: { + } + argsTuple: [] + returns: void + }> + /** + * Defines the shape of the global and local state of the application. + */ + state: { + global: { + 'currentIndex'?: IntegerState + } + } +} +/** + * Defines the possible abi call signatures + */ +export type AlgoDidSig = keyof AlgoDid['methods'] +/** + * Defines an object containing all relevant parameters for a single call to the contract. Where TSignature is undefined, a bare call is made + */ +export type TypedCallParams = { + method: TSignature + methodArgs: TSignature extends undefined ? undefined : Array +} & AppClientCallCoreParams & CoreAppCallArgs +/** + * Defines the arguments required for a bare call + */ +export type BareCallArgs = Omit +/** + * Maps a method signature from the AlgoDid smart contract to the method's arguments in either tuple of struct form + */ +export type MethodArgs = AlgoDid['methods'][TSignature]['argsObj' | 'argsTuple'] +/** + * Maps a method signature from the AlgoDid smart contract to the method's return type + */ +export type MethodReturn = AlgoDid['methods'][TSignature]['returns'] + +/** + * A factory for available 'create' calls + */ +export type AlgoDidCreateCalls = (typeof AlgoDidCallFactory)['create'] +/** + * Defines supported create methods for this smart contract + */ +export type AlgoDidCreateCallParams = + | (TypedCallParams<'createApplication()void'> & (OnCompleteNoOp)) +/** + * A factory for available 'update' calls + */ +export type AlgoDidUpdateCalls = (typeof AlgoDidCallFactory)['update'] +/** + * Defines supported update methods for this smart contract + */ +export type AlgoDidUpdateCallParams = + | TypedCallParams<'updateApplication()void'> +/** + * Defines arguments required for the deploy method. + */ +export type AlgoDidDeployArgs = { + deployTimeParams?: TealTemplateParams + /** + * A delegate which takes a create call factory and returns the create call params for this smart contract + */ + createCall?: (callFactory: AlgoDidCreateCalls) => AlgoDidCreateCallParams + /** + * A delegate which takes a update call factory and returns the update call params for this smart contract + */ + updateCall?: (callFactory: AlgoDidUpdateCalls) => AlgoDidUpdateCallParams +} + + +/** + * Exposes methods for constructing all available smart contract calls + */ +export abstract class AlgoDidCallFactory { + /** + * Gets available create call factories + */ + static get create() { + return { + /** + * Constructs a create call for the AlgoDID smart contract using the createApplication()void ABI method + * + * @param args Any args for the contract call + * @param params Any additional parameters for the call + * @returns A TypedCallParams object for the call + */ + createApplication(args: MethodArgs<'createApplication()void'>, params: AppClientCallCoreParams & CoreAppCallArgs & AppClientCompilationParams & (OnCompleteNoOp) = {}) { + return { + method: 'createApplication()void' as const, + methodArgs: Array.isArray(args) ? args : [], + ...params, + } + }, + } + } + + /** + * Gets available update call factories + */ + static get update() { + return { + /** + * Constructs an update call for the AlgoDID smart contract using the updateApplication()void ABI method + * + * @param args Any args for the contract call + * @param params Any additional parameters for the call + * @returns A TypedCallParams object for the call + */ + updateApplication(args: MethodArgs<'updateApplication()void'>, params: AppClientCallCoreParams & CoreAppCallArgs & AppClientCompilationParams = {}) { + return { + method: 'updateApplication()void' as const, + methodArgs: Array.isArray(args) ? args : [], + ...params, + } + }, + } + } + + /** + * Constructs a no op call for the startUpload(address,uint64,uint64,pay)void ABI method + * + * Allocate boxes to begin data upload process + * + * @param args Any args for the contract call + * @param params Any additional parameters for the call + * @returns A TypedCallParams object for the call + */ + static startUpload(args: MethodArgs<'startUpload(address,uint64,uint64,pay)void'>, params: AppClientCallCoreParams & CoreAppCallArgs) { + return { + method: 'startUpload(address,uint64,uint64,pay)void' as const, + methodArgs: Array.isArray(args) ? args : [args.pubKey, args.numBoxes, args.endBoxSize, args.mbrPayment], + ...params, + } + } + /** + * Constructs a no op call for the upload(address,uint64,uint64,byte[])void ABI method + * + * Upload data to a specific offset in a box + * + * @param args Any args for the contract call + * @param params Any additional parameters for the call + * @returns A TypedCallParams object for the call + */ + static upload(args: MethodArgs<'upload(address,uint64,uint64,byte[])void'>, params: AppClientCallCoreParams & CoreAppCallArgs) { + return { + method: 'upload(address,uint64,uint64,byte[])void' as const, + methodArgs: Array.isArray(args) ? args : [args.pubKey, args.boxIndex, args.offset, args.data], + ...params, + } + } + /** + * Constructs a no op call for the finishUpload(address)void ABI method + * + * Mark uploading as false + * + * @param args Any args for the contract call + * @param params Any additional parameters for the call + * @returns A TypedCallParams object for the call + */ + static finishUpload(args: MethodArgs<'finishUpload(address)void'>, params: AppClientCallCoreParams & CoreAppCallArgs) { + return { + method: 'finishUpload(address)void' as const, + methodArgs: Array.isArray(args) ? args : [args.pubKey], + ...params, + } + } + /** + * Constructs a no op call for the startDelete(address)void ABI method + * + * Starts the deletion process for the data associated with a DID + * + * @param args Any args for the contract call + * @param params Any additional parameters for the call + * @returns A TypedCallParams object for the call + */ + static startDelete(args: MethodArgs<'startDelete(address)void'>, params: AppClientCallCoreParams & CoreAppCallArgs) { + return { + method: 'startDelete(address)void' as const, + methodArgs: Array.isArray(args) ? args : [args.pubKey], + ...params, + } + } + /** + * Constructs a no op call for the deleteData(address,uint64)void ABI method + * + * Deletes a box of data + * + * @param args Any args for the contract call + * @param params Any additional parameters for the call + * @returns A TypedCallParams object for the call + */ + static deleteData(args: MethodArgs<'deleteData(address,uint64)void'>, params: AppClientCallCoreParams & CoreAppCallArgs) { + return { + method: 'deleteData(address,uint64)void' as const, + methodArgs: Array.isArray(args) ? args : [args.pubKey, args.boxIndex], + ...params, + } + } + /** + * Constructs a no op call for the dummy()void ABI method + * + * Dummy function to add extra box references for deleteData.Boxes are 32k, but a single app call can only inlcude enough references to read/write 8kat a time. Thus when a box is deleted, we need to add additional dummy calls with boxreferences to increase the total read/write budget to 32k. + * + * @param args Any args for the contract call + * @param params Any additional parameters for the call + * @returns A TypedCallParams object for the call + */ + static dummy(args: MethodArgs<'dummy()void'>, params: AppClientCallCoreParams & CoreAppCallArgs) { + return { + method: 'dummy()void' as const, + methodArgs: Array.isArray(args) ? args : [], + ...params, + } + } +} + +/** + * A client to make calls to the AlgoDID smart contract + */ +export class AlgoDidClient { + /** + * The underlying `ApplicationClient` for when you want to have more flexibility + */ + public readonly appClient: ApplicationClient + + private readonly sender: SendTransactionFrom | undefined + + /** + * Creates a new instance of `AlgoDidClient` + * + * @param appDetails appDetails The details to identify the app to deploy + * @param algod An algod client instance + */ + constructor(appDetails: AppDetails, private algod: Algodv2) { + this.sender = appDetails.sender + this.appClient = algokit.getAppClient({ + ...appDetails, + app: APP_SPEC + }, algod) + } + + /** + * Checks for decode errors on the AppCallTransactionResult and maps the return value to the specified generic type + * + * @param result The AppCallTransactionResult to be mapped + * @param returnValueFormatter An optional delegate to format the return value if required + * @returns The smart contract response with an updated return value + */ + protected mapReturnValue(result: AppCallTransactionResult, returnValueFormatter?: (value: any) => TReturn): AppCallTransactionResultOfType { + if(result.return?.decodeError) { + throw result.return.decodeError + } + const returnValue = result.return?.returnValue !== undefined && returnValueFormatter !== undefined + ? returnValueFormatter(result.return.returnValue) + : result.return?.returnValue as TReturn | undefined + return { ...result, return: returnValue } + } + + /** + * Calls the ABI method with the matching signature using an onCompletion code of NO_OP + * + * @param typedCallParams An object containing the method signature, args, and any other relevant parameters + * @param returnValueFormatter An optional delegate which when provided will be used to map non-undefined return values to the target type + * @returns The result of the smart contract call + */ + public async call(typedCallParams: TypedCallParams, returnValueFormatter?: (value: any) => MethodReturn) { + return this.mapReturnValue>(await this.appClient.call(typedCallParams), returnValueFormatter) + } + + /** + * Idempotently deploys the AlgoDID smart contract. + * + * @param params The arguments for the contract calls and any additional parameters for the call + * @returns The deployment result + */ + public deploy(params: AlgoDidDeployArgs & AppClientDeployCoreParams = {}): ReturnType { + const createArgs = params.createCall?.(AlgoDidCallFactory.create) + const updateArgs = params.updateCall?.(AlgoDidCallFactory.update) + return this.appClient.deploy({ + ...params, + updateArgs, + createArgs, + createOnCompleteAction: createArgs?.onCompleteAction, + }) + } + + /** + * Gets available create methods + */ + public get create() { + const $this = this + return { + /** + * Creates a new instance of the AlgoDID smart contract using the createApplication()void ABI method. + * + * @param args The arguments for the smart contract call + * @param params Any additional parameters for the call + * @returns The create result + */ + async createApplication(args: MethodArgs<'createApplication()void'>, params: AppClientCallCoreParams & AppClientCompilationParams & (OnCompleteNoOp) = {}): Promise>> { + return $this.mapReturnValue(await $this.appClient.create(AlgoDidCallFactory.create.createApplication(args, params))) + }, + } + } + + /** + * Gets available update methods + */ + public get update() { + const $this = this + return { + /** + * Updates an existing instance of the AlgoDID smart contract using the updateApplication()void ABI method. + * + * @param args The arguments for the smart contract call + * @param params Any additional parameters for the call + * @returns The update result + */ + async updateApplication(args: MethodArgs<'updateApplication()void'>, params: AppClientCallCoreParams & AppClientCompilationParams = {}): Promise>> { + return $this.mapReturnValue(await $this.appClient.update(AlgoDidCallFactory.update.updateApplication(args, params))) + }, + } + } + + /** + * Makes a clear_state call to an existing instance of the AlgoDID smart contract. + * + * @param args The arguments for the bare call + * @returns The clear_state result + */ + public clearState(args: BareCallArgs & AppClientCallCoreParams & CoreAppCallArgs = {}) { + return this.appClient.clearState(args) + } + + /** + * Calls the startUpload(address,uint64,uint64,pay)void ABI method. + * + * Allocate boxes to begin data upload process + * + * @param args The arguments for the contract call + * @param params Any additional parameters for the call + * @returns The result of the call + */ + public startUpload(args: MethodArgs<'startUpload(address,uint64,uint64,pay)void'>, params: AppClientCallCoreParams & CoreAppCallArgs = {}) { + return this.call(AlgoDidCallFactory.startUpload(args, params)) + } + + /** + * Calls the upload(address,uint64,uint64,byte[])void ABI method. + * + * Upload data to a specific offset in a box + * + * @param args The arguments for the contract call + * @param params Any additional parameters for the call + * @returns The result of the call + */ + public upload(args: MethodArgs<'upload(address,uint64,uint64,byte[])void'>, params: AppClientCallCoreParams & CoreAppCallArgs = {}) { + return this.call(AlgoDidCallFactory.upload(args, params)) + } + + /** + * Calls the finishUpload(address)void ABI method. + * + * Mark uploading as false + * + * @param args The arguments for the contract call + * @param params Any additional parameters for the call + * @returns The result of the call + */ + public finishUpload(args: MethodArgs<'finishUpload(address)void'>, params: AppClientCallCoreParams & CoreAppCallArgs = {}) { + return this.call(AlgoDidCallFactory.finishUpload(args, params)) + } + + /** + * Calls the startDelete(address)void ABI method. + * + * Starts the deletion process for the data associated with a DID + * + * @param args The arguments for the contract call + * @param params Any additional parameters for the call + * @returns The result of the call + */ + public startDelete(args: MethodArgs<'startDelete(address)void'>, params: AppClientCallCoreParams & CoreAppCallArgs = {}) { + return this.call(AlgoDidCallFactory.startDelete(args, params)) + } + + /** + * Calls the deleteData(address,uint64)void ABI method. + * + * Deletes a box of data + * + * @param args The arguments for the contract call + * @param params Any additional parameters for the call + * @returns The result of the call + */ + public deleteData(args: MethodArgs<'deleteData(address,uint64)void'>, params: AppClientCallCoreParams & CoreAppCallArgs = {}) { + return this.call(AlgoDidCallFactory.deleteData(args, params)) + } + + /** + * Calls the dummy()void ABI method. + * + * Dummy function to add extra box references for deleteData.Boxes are 32k, but a single app call can only inlcude enough references to read/write 8kat a time. Thus when a box is deleted, we need to add additional dummy calls with boxreferences to increase the total read/write budget to 32k. + * + * @param args The arguments for the contract call + * @param params Any additional parameters for the call + * @returns The result of the call + */ + public dummy(args: MethodArgs<'dummy()void'>, params: AppClientCallCoreParams & CoreAppCallArgs = {}) { + return this.call(AlgoDidCallFactory.dummy(args, params)) + } + + /** + * Extracts a binary state value out of an AppState dictionary + * + * @param state The state dictionary containing the state value + * @param key The key of the state value + * @returns A BinaryState instance containing the state value, or undefined if the key was not found + */ + private static getBinaryState(state: AppState, key: string): BinaryState | undefined { + const value = state[key] + if (!value) return undefined + if (!('valueRaw' in value)) + throw new Error(`Failed to parse state value for ${key}; received an int when expected a byte array`) + return { + asString(): string { + return value.value + }, + asByteArray(): Uint8Array { + return value.valueRaw + } + } + } + + /** + * Extracts a integer state value out of an AppState dictionary + * + * @param state The state dictionary containing the state value + * @param key The key of the state value + * @returns An IntegerState instance containing the state value, or undefined if the key was not found + */ + private static getIntegerState(state: AppState, key: string): IntegerState | undefined { + const value = state[key] + if (!value) return undefined + if ('valueRaw' in value) + throw new Error(`Failed to parse state value for ${key}; received a byte array when expected a number`) + return { + asBigInt() { + return typeof value.value === 'bigint' ? value.value : BigInt(value.value) + }, + asNumber(): number { + return typeof value.value === 'bigint' ? Number(value.value) : value.value + }, + } + } + + /** + * Returns the smart contract's global state wrapped in a strongly typed accessor with options to format the stored value + */ + public async getGlobalState(): Promise { + const state = await this.appClient.getGlobalState() + return { + get currentIndex() { + return AlgoDidClient.getIntegerState(state, 'currentIndex') + }, + } + } + + public compose(): AlgoDidComposer { + const client = this + const atc = new AtomicTransactionComposer() + let promiseChain:Promise = Promise.resolve() + const resultMappers: Array any)> = [] + return { + startUpload(args: MethodArgs<'startUpload(address,uint64,uint64,pay)void'>, params?: AppClientCallCoreParams & CoreAppCallArgs) { + promiseChain = promiseChain.then(() => client.startUpload(args, {...params, sendParams: {...params?.sendParams, skipSending: true, atc}})) + resultMappers.push(undefined) + return this + }, + upload(args: MethodArgs<'upload(address,uint64,uint64,byte[])void'>, params?: AppClientCallCoreParams & CoreAppCallArgs) { + promiseChain = promiseChain.then(() => client.upload(args, {...params, sendParams: {...params?.sendParams, skipSending: true, atc}})) + resultMappers.push(undefined) + return this + }, + finishUpload(args: MethodArgs<'finishUpload(address)void'>, params?: AppClientCallCoreParams & CoreAppCallArgs) { + promiseChain = promiseChain.then(() => client.finishUpload(args, {...params, sendParams: {...params?.sendParams, skipSending: true, atc}})) + resultMappers.push(undefined) + return this + }, + startDelete(args: MethodArgs<'startDelete(address)void'>, params?: AppClientCallCoreParams & CoreAppCallArgs) { + promiseChain = promiseChain.then(() => client.startDelete(args, {...params, sendParams: {...params?.sendParams, skipSending: true, atc}})) + resultMappers.push(undefined) + return this + }, + deleteData(args: MethodArgs<'deleteData(address,uint64)void'>, params?: AppClientCallCoreParams & CoreAppCallArgs) { + promiseChain = promiseChain.then(() => client.deleteData(args, {...params, sendParams: {...params?.sendParams, skipSending: true, atc}})) + resultMappers.push(undefined) + return this + }, + dummy(args: MethodArgs<'dummy()void'>, params?: AppClientCallCoreParams & CoreAppCallArgs) { + promiseChain = promiseChain.then(() => client.dummy(args, {...params, sendParams: {...params?.sendParams, skipSending: true, atc}})) + resultMappers.push(undefined) + return this + }, + get update() { + const $this = this + return { + updateApplication(args: MethodArgs<'updateApplication()void'>, params?: AppClientCallCoreParams & AppClientCompilationParams) { + promiseChain = promiseChain.then(() => client.update.updateApplication(args, {...params, sendParams: {...params?.sendParams, skipSending: true, atc}})) + resultMappers.push(undefined) + return $this + }, + } + }, + clearState(args?: BareCallArgs & AppClientCallCoreParams & CoreAppCallArgs) { + promiseChain = promiseChain.then(() => client.clearState({...args, sendParams: {...args?.sendParams, skipSending: true, atc}})) + resultMappers.push(undefined) + return this + }, + addTransaction(txn: TransactionWithSigner | TransactionToSign | Transaction | Promise, defaultSender?: SendTransactionFrom) { + promiseChain = promiseChain.then(async () => atc.addTransaction(await algokit.getTransactionWithSigner(txn, defaultSender ?? client.sender))) + return this + }, + async atc() { + await promiseChain + return atc + }, + async execute() { + await promiseChain + const result = await algokit.sendAtomicTransactionComposer({ atc, sendParams: {} }, client.algod) + return { + ...result, + returns: result.returns?.map((val, i) => resultMappers[i] !== undefined ? resultMappers[i]!(val.returnValue) : val.returnValue) + } + } + } as unknown as AlgoDidComposer + } +} +export type AlgoDidComposer = { + /** + * Calls the startUpload(address,uint64,uint64,pay)void ABI method. + * + * Allocate boxes to begin data upload process + * + * @param args The arguments for the contract call + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + startUpload(args: MethodArgs<'startUpload(address,uint64,uint64,pay)void'>, params?: AppClientCallCoreParams & CoreAppCallArgs): AlgoDidComposer<[...TReturns, MethodReturn<'startUpload(address,uint64,uint64,pay)void'>]> + + /** + * Calls the upload(address,uint64,uint64,byte[])void ABI method. + * + * Upload data to a specific offset in a box + * + * @param args The arguments for the contract call + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + upload(args: MethodArgs<'upload(address,uint64,uint64,byte[])void'>, params?: AppClientCallCoreParams & CoreAppCallArgs): AlgoDidComposer<[...TReturns, MethodReturn<'upload(address,uint64,uint64,byte[])void'>]> + + /** + * Calls the finishUpload(address)void ABI method. + * + * Mark uploading as false + * + * @param args The arguments for the contract call + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + finishUpload(args: MethodArgs<'finishUpload(address)void'>, params?: AppClientCallCoreParams & CoreAppCallArgs): AlgoDidComposer<[...TReturns, MethodReturn<'finishUpload(address)void'>]> + + /** + * Calls the startDelete(address)void ABI method. + * + * Starts the deletion process for the data associated with a DID + * + * @param args The arguments for the contract call + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + startDelete(args: MethodArgs<'startDelete(address)void'>, params?: AppClientCallCoreParams & CoreAppCallArgs): AlgoDidComposer<[...TReturns, MethodReturn<'startDelete(address)void'>]> + + /** + * Calls the deleteData(address,uint64)void ABI method. + * + * Deletes a box of data + * + * @param args The arguments for the contract call + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + deleteData(args: MethodArgs<'deleteData(address,uint64)void'>, params?: AppClientCallCoreParams & CoreAppCallArgs): AlgoDidComposer<[...TReturns, MethodReturn<'deleteData(address,uint64)void'>]> + + /** + * Calls the dummy()void ABI method. + * + * Dummy function to add extra box references for deleteData.Boxes are 32k, but a single app call can only inlcude enough references to read/write 8kat a time. Thus when a box is deleted, we need to add additional dummy calls with boxreferences to increase the total read/write budget to 32k. + * + * @param args The arguments for the contract call + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + dummy(args: MethodArgs<'dummy()void'>, params?: AppClientCallCoreParams & CoreAppCallArgs): AlgoDidComposer<[...TReturns, MethodReturn<'dummy()void'>]> + + /** + * Gets available update methods + */ + readonly update: { + /** + * Updates an existing instance of the AlgoDID smart contract using the updateApplication()void ABI method. + * + * @param args The arguments for the smart contract call + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + updateApplication(args: MethodArgs<'updateApplication()void'>, params?: AppClientCallCoreParams & AppClientCompilationParams): AlgoDidComposer<[...TReturns, MethodReturn<'updateApplication()void'>]> + } + + /** + * Makes a clear_state call to an existing instance of the AlgoDID smart contract. + * + * @param args The arguments for the bare call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + clearState(args?: BareCallArgs & AppClientCallCoreParams & CoreAppCallArgs): AlgoDidComposer<[...TReturns, undefined]> + + /** + * Adds a transaction to the composer + * + * @param txn One of: A TransactionWithSigner object (returned as is), a TransactionToSign object (signer is obtained from the signer property), a Transaction object (signer is extracted from the defaultSender parameter), an async SendTransactionResult returned by one of algokit utils helpers (signer is obtained from the defaultSender parameter) + * @param defaultSender The default sender to be used to obtain a signer where the object provided to the transaction parameter does not include a signer. + */ + addTransaction(txn: TransactionWithSigner | TransactionToSign | Transaction | Promise, defaultSender?: SendTransactionFrom): AlgoDidComposer + /** + * Returns the underlying AtomicTransactionComposer instance + */ + atc(): Promise + /** + * Executes the transaction group and returns an array of results + */ + execute(): Promise> +} +export type AlgoDidComposerResults = { + returns: TReturns + groupId: string + txIds: string[] + transactions: Transaction[] +} diff --git a/reference_contract/jest.config.js b/reference_contract/jest.config.js new file mode 100644 index 0000000..3745fc2 --- /dev/null +++ b/reference_contract/jest.config.js @@ -0,0 +1,5 @@ +/** @type {import('ts-jest').JestConfigWithTsJest} */ +module.exports = { + preset: 'ts-jest', + testEnvironment: 'node', +}; diff --git a/reference_contract/package-lock.json b/reference_contract/package-lock.json new file mode 100644 index 0000000..01a059c --- /dev/null +++ b/reference_contract/package-lock.json @@ -0,0 +1,10737 @@ +{ + "name": "algo-did", + "version": "0.0.0", + "lockfileVersion": 2, + "requires": true, + "packages": { + "": { + "name": "algo-did", + "version": "0.0.0", + "license": "MIT", + "dependencies": { + "@algorandfoundation/algokit-utils": "^5.1.3", + "@algorandfoundation/tealscript": "^0.51.1", + "algosdk": "^2.6.0" + }, + "devDependencies": { + "@algorandfoundation/algokit-client-generator": "^2.2.1", + "@jest/globals": "^29.5.0", + "@typescript-eslint/eslint-plugin": "^5.13.0", + "@typescript-eslint/parser": "^5.0.0", + "eslint": "^7.32.0 || ^8.2.0", + "eslint-config-airbnb-base": "^15.0.0", + "eslint-config-airbnb-typescript": "^17.0.0", + "eslint-plugin-import": "^2.25.2", + "jest": "^29.5.0", + "ts-jest": "^29.1.0", + "typescript": "5.0.2" + } + }, + "node_modules/@algorandfoundation/algokit-client-generator": { + "version": "2.2.1", + "dev": true, + "license": "MIT", + "dependencies": { + "@algorandfoundation/algokit-utils": "^2.1.0", + "chalk": "^4.1.2", + "change-case": "^4.1.2", + "commander": "^10.0.1", + "jsonschema": "^1.4.1" + }, + "bin": { + "algokit-client-generator": "bin/cli.js", + "algokitgen": "bin/cli.js" + } + }, + "node_modules/@algorandfoundation/algokit-client-generator/node_modules/@algorandfoundation/algokit-utils": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/@algorandfoundation/algokit-utils/-/algokit-utils-2.3.2.tgz", + "integrity": "sha512-+Q4b8OVXogjkthapH04k+AqY19hxklfXFTmvoaQdQbbo2rUk1AgSXBRq0ThVg7n7RhfSMMUh0ZIL5bpse7MSKA==", + "dev": true, + "dependencies": { + "algosdk": "^2.3.0", + "buffer": "^6.0.3" + }, + "engines": { + "node": ">=16.0" + } + }, + "node_modules/@algorandfoundation/algokit-utils": { + "version": "5.1.3", + "resolved": "https://registry.npmjs.org/@algorandfoundation/algokit-utils/-/algokit-utils-5.1.3.tgz", + "integrity": "sha512-TYkJioqOSG4DhW8phAdMhGi5QUla64PRzoi+5Ixq4LA371xZ2zegQFvHjoXZXMIIJaD8HckihlDju7K7U3xj8Q==", + "dependencies": { + "buffer": "^6.0.3" + }, + "engines": { + "node": ">=18.0" + }, + "peerDependencies": { + "algosdk": "^2.7.0" + } + }, + "node_modules/@algorandfoundation/tealscript": { + "version": "0.51.1", + "resolved": "https://registry.npmjs.org/@algorandfoundation/tealscript/-/tealscript-0.51.1.tgz", + "integrity": "sha512-VM1orcyoy1VqzwD2jKNxbef6elq94KneH5SuXYM8FdBsFEqD7STukIWGWBQ/5om/LbtomvhwHx7GrWx6m+HjWA==", + "dependencies": { + "@microsoft/tsdoc": "^0.14.2", + "argparse": "^2.0.1", + "dotenv": "^16.3.1", + "node-fetch": "2", + "source-map": "^0.7.4", + "ts-morph": "^20.0.0", + "typescript": "^4.9.3", + "vlq": "^2.0.4" + }, + "bin": { + "tealscript": "dist/bin/tealscript.js" + } + }, + "node_modules/@algorandfoundation/tealscript/node_modules/source-map": { + "version": "0.7.4", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.7.4.tgz", + "integrity": "sha512-l3BikUxvPOcn5E74dZiq5BGsTb5yEwhaTSzccU6t4sDOH8NWJCstKO5QT2CvtFoK6F0saL7p9xHAqHOlCPJygA==", + "engines": { + "node": ">= 8" + } + }, + "node_modules/@algorandfoundation/tealscript/node_modules/typescript": { + "version": "4.9.5", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.9.5.tgz", + "integrity": "sha512-1FXk9E2Hm+QzZQ7z+McJiHL4NW1F2EzMu9Nq9i3zAaGqibafqYwCVU6WyWAuyQRRzOlxou8xZSyXLEN8oKj24g==", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=4.2.0" + } + }, + "node_modules/@ampproject/remapping": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/@ampproject/remapping/-/remapping-2.2.1.tgz", + "integrity": "sha512-lFMjJTrFL3j7L9yBxwYfCq2k6qqwHyzuUl/XBnif78PWTJYyL/dfowQHWE3sp6U6ZzqWiiIZnpTMO96zhkjwtg==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@jridgewell/gen-mapping": "^0.3.0", + "@jridgewell/trace-mapping": "^0.3.9" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/code-frame": { + "version": "7.22.5", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/highlight": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/compat-data": { + "version": "7.22.5", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/core": { + "version": "7.22.5", + "dev": true, + "license": "MIT", + "dependencies": { + "@ampproject/remapping": "^2.2.0", + "@babel/code-frame": "^7.22.5", + "@babel/generator": "^7.22.5", + "@babel/helper-compilation-targets": "^7.22.5", + "@babel/helper-module-transforms": "^7.22.5", + "@babel/helpers": "^7.22.5", + "@babel/parser": "^7.22.5", + "@babel/template": "^7.22.5", + "@babel/traverse": "^7.22.5", + "@babel/types": "^7.22.5", + "convert-source-map": "^1.7.0", + "debug": "^4.1.0", + "gensync": "^1.0.0-beta.2", + "json5": "^2.2.2", + "semver": "^6.3.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/babel" + } + }, + "node_modules/@babel/generator": { + "version": "7.22.5", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.22.5", + "@jridgewell/gen-mapping": "^0.3.2", + "@jridgewell/trace-mapping": "^0.3.17", + "jsesc": "^2.5.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-compilation-targets": { + "version": "7.22.5", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/compat-data": "^7.22.5", + "@babel/helper-validator-option": "^7.22.5", + "browserslist": "^4.21.3", + "lru-cache": "^5.1.1", + "semver": "^6.3.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-compilation-targets/node_modules/lru-cache": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz", + "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==", + "dev": true, + "license": "ISC", + "dependencies": { + "yallist": "^3.0.2" + } + }, + "node_modules/@babel/helper-compilation-targets/node_modules/yallist": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz", + "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==", + "dev": true, + "license": "ISC" + }, + "node_modules/@babel/helper-environment-visitor": { + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-environment-visitor/-/helper-environment-visitor-7.22.5.tgz", + "integrity": "sha512-XGmhECfVA/5sAt+H+xpSg0mfrHq6FzNr9Oxh7PSEBBRUb/mL7Kz3NICXb194rCqAEdxkhPT1a88teizAFyvk8Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-function-name": { + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.22.5.tgz", + "integrity": "sha512-wtHSq6jMRE3uF2otvfuD3DIvVhOsSNshQl0Qrd7qC9oQJzHvOL4qQXlQn2916+CXGywIjpGuIkoyZRRxHPiNQQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/template": "^7.22.5", + "@babel/types": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-hoist-variables": { + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-hoist-variables/-/helper-hoist-variables-7.22.5.tgz", + "integrity": "sha512-wGjk9QZVzvknA6yKIUURb8zY3grXCcOZt+/7Wcy8O2uctxhplmUPkOdlgoNhmdVee2c92JXbf1xpMtVNbfoxRw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-imports": { + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.22.5.tgz", + "integrity": "sha512-8Dl6+HD/cKifutF5qGd/8ZJi84QeAKh+CEe1sBzz8UayBBGg1dAIJrdHOcOM5b2MpzWL2yuotJTtGjETq0qjXg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-transforms": { + "version": "7.22.5", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-environment-visitor": "^7.22.5", + "@babel/helper-module-imports": "^7.22.5", + "@babel/helper-simple-access": "^7.22.5", + "@babel/helper-split-export-declaration": "^7.22.5", + "@babel/helper-validator-identifier": "^7.22.5", + "@babel/template": "^7.22.5", + "@babel/traverse": "^7.22.5", + "@babel/types": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-plugin-utils": { + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.22.5.tgz", + "integrity": "sha512-uLls06UVKgFG9QD4OeFYLEGteMIAa5kpTPcFL28yuCIIzsf6ZyKZMllKVOCZFhiZ5ptnwX4mtKdWCBE/uT4amg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-simple-access": { + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-simple-access/-/helper-simple-access-7.22.5.tgz", + "integrity": "sha512-n0H99E/K+Bika3++WNL17POvo4rKWZ7lZEp1Q+fStVbUi8nxPQEBOlTmCOxW/0JsS56SKKQ+ojAe2pHKJHN35w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-split-export-declaration": { + "version": "7.22.5", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-string-parser": { + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.22.5.tgz", + "integrity": "sha512-mM4COjgZox8U+JcXQwPijIZLElkgEpO5rsERVDJTc2qfCDfERyob6k5WegS14SX18IIjv+XD+GrqNumY5JRCDw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-identifier": { + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.22.5.tgz", + "integrity": "sha512-aJXu+6lErq8ltp+JhkJUfk1MTGyuA4v7f3pA+BJ5HLfNC6nAQ0Cpi9uOquUj8Hehg0aUiHzWQbOVJGao6ztBAQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-option": { + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.22.5.tgz", + "integrity": "sha512-R3oB6xlIVKUnxNUxbmgq7pKjxpru24zlimpE8WK47fACIlM0II/Hm1RS8IaOI7NgCr6LNS+jl5l75m20npAziw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helpers": { + "version": "7.22.5", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/template": "^7.22.5", + "@babel/traverse": "^7.22.5", + "@babel/types": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/highlight": { + "version": "7.22.5", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-validator-identifier": "^7.22.5", + "chalk": "^2.0.0", + "js-tokens": "^4.0.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/highlight/node_modules/ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-convert": "^1.9.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/@babel/highlight/node_modules/chalk": { + "version": "2.4.2", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/@babel/highlight/node_modules/color-convert": { + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz", + "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-name": "1.1.3" + } + }, + "node_modules/@babel/highlight/node_modules/color-name": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", + "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@babel/highlight/node_modules/escape-string-regexp": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", + "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/@babel/highlight/node_modules/has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/@babel/highlight/node_modules/supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "dev": true, + "license": "MIT", + "dependencies": { + "has-flag": "^3.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/@babel/parser": { + "version": "7.22.5", + "dev": true, + "license": "MIT", + "bin": { + "parser": "bin/babel-parser.js" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/plugin-syntax-async-generators": { + "version": "7.8.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-async-generators/-/plugin-syntax-async-generators-7.8.4.tgz", + "integrity": "sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-bigint": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-bigint/-/plugin-syntax-bigint-7.8.3.tgz", + "integrity": "sha512-wnTnFlG+YxQm3vDxpGE57Pj0srRU4sHE/mDkt1qv2YJJSeUAec2ma4WLUnUPeKjyrfntVwe/N6dCXpU+zL3Npg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-class-properties": { + "version": "7.12.13", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-class-properties/-/plugin-syntax-class-properties-7.12.13.tgz", + "integrity": "sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.12.13" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-import-meta": { + "version": "7.10.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-meta/-/plugin-syntax-import-meta-7.10.4.tgz", + "integrity": "sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.10.4" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-json-strings": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-json-strings/-/plugin-syntax-json-strings-7.8.3.tgz", + "integrity": "sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-jsx": { + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.22.5.tgz", + "integrity": "sha512-gvyP4hZrgrs/wWMaocvxZ44Hw0b3W8Pe+cMxc8V1ULQ07oh8VNbIRaoD1LRZVTvD+0nieDKjfgKg89sD7rrKrg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-logical-assignment-operators": { + "version": "7.10.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-logical-assignment-operators/-/plugin-syntax-logical-assignment-operators-7.10.4.tgz", + "integrity": "sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.10.4" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-nullish-coalescing-operator": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-nullish-coalescing-operator/-/plugin-syntax-nullish-coalescing-operator-7.8.3.tgz", + "integrity": "sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-numeric-separator": { + "version": "7.10.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-numeric-separator/-/plugin-syntax-numeric-separator-7.10.4.tgz", + "integrity": "sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.10.4" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-object-rest-spread": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-object-rest-spread/-/plugin-syntax-object-rest-spread-7.8.3.tgz", + "integrity": "sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-optional-catch-binding": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-optional-catch-binding/-/plugin-syntax-optional-catch-binding-7.8.3.tgz", + "integrity": "sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-optional-chaining": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-optional-chaining/-/plugin-syntax-optional-chaining-7.8.3.tgz", + "integrity": "sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-top-level-await": { + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-top-level-await/-/plugin-syntax-top-level-await-7.14.5.tgz", + "integrity": "sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-typescript": { + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.22.5.tgz", + "integrity": "sha512-1mS2o03i7t1c6VzH6fdQ3OA8tcEIxwG18zIPRp+UY1Ihv6W+XZzBCVxExF9upussPXJ0xE9XRHwMoNs1ep/nRQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/template": { + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.22.5.tgz", + "integrity": "sha512-X7yV7eiwAxdj9k94NEylvbVHLiVG1nvzCV2EAowhxLTwODV1jl9UzZ48leOC0sH7OnuHrIkllaBgneUykIcZaw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.22.5", + "@babel/parser": "^7.22.5", + "@babel/types": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/traverse": { + "version": "7.22.5", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.22.5", + "@babel/generator": "^7.22.5", + "@babel/helper-environment-visitor": "^7.22.5", + "@babel/helper-function-name": "^7.22.5", + "@babel/helper-hoist-variables": "^7.22.5", + "@babel/helper-split-export-declaration": "^7.22.5", + "@babel/parser": "^7.22.5", + "@babel/types": "^7.22.5", + "debug": "^4.1.0", + "globals": "^11.1.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/traverse/node_modules/globals": { + "version": "11.12.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz", + "integrity": "sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/@babel/types": { + "version": "7.22.5", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-string-parser": "^7.22.5", + "@babel/helper-validator-identifier": "^7.22.5", + "to-fast-properties": "^2.0.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@bcoe/v8-coverage": { + "version": "0.2.3", + "resolved": "https://registry.npmjs.org/@bcoe/v8-coverage/-/v8-coverage-0.2.3.tgz", + "integrity": "sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@eslint-community/eslint-utils": { + "version": "4.4.0", + "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.4.0.tgz", + "integrity": "sha512-1/sA4dwrzBAyeUoQ6oxahHKmrZvsnLCg4RfxW3ZFGGmQkSNQPFNLV9CUEFQP1x9EYXHTo5p6xdhZM1Ne9p/AfA==", + "dev": true, + "license": "MIT", + "dependencies": { + "eslint-visitor-keys": "^3.3.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "peerDependencies": { + "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0" + } + }, + "node_modules/@eslint-community/regexpp": { + "version": "4.5.1", + "dev": true, + "license": "MIT", + "engines": { + "node": "^12.0.0 || ^14.0.0 || >=16.0.0" + } + }, + "node_modules/@eslint/eslintrc": { + "version": "2.0.3", + "dev": true, + "license": "MIT", + "dependencies": { + "ajv": "^6.12.4", + "debug": "^4.3.2", + "espree": "^9.5.2", + "globals": "^13.19.0", + "ignore": "^5.2.0", + "import-fresh": "^3.2.1", + "js-yaml": "^4.1.0", + "minimatch": "^3.1.2", + "strip-json-comments": "^3.1.1" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/@eslint/js": { + "version": "8.43.0", + "dev": true, + "license": "MIT", + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + } + }, + "node_modules/@humanwhocodes/config-array": { + "version": "0.11.10", + "resolved": "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.11.10.tgz", + "integrity": "sha512-KVVjQmNUepDVGXNuoRRdmmEjruj0KfiGSbS8LVc12LMsWDQzRXJ0qdhN8L8uUigKpfEHRhlaQFY0ib1tnUbNeQ==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@humanwhocodes/object-schema": "^1.2.1", + "debug": "^4.1.1", + "minimatch": "^3.0.5" + }, + "engines": { + "node": ">=10.10.0" + } + }, + "node_modules/@humanwhocodes/module-importer": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz", + "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=12.22" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/nzakas" + } + }, + "node_modules/@humanwhocodes/object-schema": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-1.2.1.tgz", + "integrity": "sha512-ZnQMnLV4e7hDlUvw8H+U8ASL02SS2Gn6+9Ac3wGGLIe7+je2AeAOxPY+izIPJDfFDb7eDjev0Us8MO1iFRN8hA==", + "dev": true, + "license": "BSD-3-Clause" + }, + "node_modules/@istanbuljs/load-nyc-config": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@istanbuljs/load-nyc-config/-/load-nyc-config-1.1.0.tgz", + "integrity": "sha512-VjeHSlIzpv/NyD3N0YuHfXOPDIixcA1q2ZV98wsMqcYlPmv2n3Yb2lYP9XMElnaFVXg5A7YLTeLu6V84uQDjmQ==", + "dev": true, + "license": "ISC", + "dependencies": { + "camelcase": "^5.3.1", + "find-up": "^4.1.0", + "get-package-type": "^0.1.0", + "js-yaml": "^3.13.1", + "resolve-from": "^5.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/@istanbuljs/load-nyc-config/node_modules/argparse": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz", + "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==", + "dev": true, + "license": "MIT", + "dependencies": { + "sprintf-js": "~1.0.2" + } + }, + "node_modules/@istanbuljs/load-nyc-config/node_modules/camelcase": { + "version": "5.3.1", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz", + "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/@istanbuljs/load-nyc-config/node_modules/js-yaml": { + "version": "3.14.1", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz", + "integrity": "sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==", + "dev": true, + "license": "MIT", + "dependencies": { + "argparse": "^1.0.7", + "esprima": "^4.0.0" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/@istanbuljs/schema": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/@istanbuljs/schema/-/schema-0.1.3.tgz", + "integrity": "sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/@jest/console": { + "version": "29.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@jest/types": "^29.5.0", + "@types/node": "*", + "chalk": "^4.0.0", + "jest-message-util": "^29.5.0", + "jest-util": "^29.5.0", + "slash": "^3.0.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@jest/core": { + "version": "29.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@jest/console": "^29.5.0", + "@jest/reporters": "^29.5.0", + "@jest/test-result": "^29.5.0", + "@jest/transform": "^29.5.0", + "@jest/types": "^29.5.0", + "@types/node": "*", + "ansi-escapes": "^4.2.1", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "exit": "^0.1.2", + "graceful-fs": "^4.2.9", + "jest-changed-files": "^29.5.0", + "jest-config": "^29.5.0", + "jest-haste-map": "^29.5.0", + "jest-message-util": "^29.5.0", + "jest-regex-util": "^29.4.3", + "jest-resolve": "^29.5.0", + "jest-resolve-dependencies": "^29.5.0", + "jest-runner": "^29.5.0", + "jest-runtime": "^29.5.0", + "jest-snapshot": "^29.5.0", + "jest-util": "^29.5.0", + "jest-validate": "^29.5.0", + "jest-watcher": "^29.5.0", + "micromatch": "^4.0.4", + "pretty-format": "^29.5.0", + "slash": "^3.0.0", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "peerDependencies": { + "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0" + }, + "peerDependenciesMeta": { + "node-notifier": { + "optional": true + } + } + }, + "node_modules/@jest/environment": { + "version": "29.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@jest/fake-timers": "^29.5.0", + "@jest/types": "^29.5.0", + "@types/node": "*", + "jest-mock": "^29.5.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@jest/expect": { + "version": "29.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "expect": "^29.5.0", + "jest-snapshot": "^29.5.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@jest/expect-utils": { + "version": "29.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "jest-get-type": "^29.4.3" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@jest/fake-timers": { + "version": "29.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@jest/types": "^29.5.0", + "@sinonjs/fake-timers": "^10.0.2", + "@types/node": "*", + "jest-message-util": "^29.5.0", + "jest-mock": "^29.5.0", + "jest-util": "^29.5.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@jest/globals": { + "version": "29.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@jest/environment": "^29.5.0", + "@jest/expect": "^29.5.0", + "@jest/types": "^29.5.0", + "jest-mock": "^29.5.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@jest/reporters": { + "version": "29.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@bcoe/v8-coverage": "^0.2.3", + "@jest/console": "^29.5.0", + "@jest/test-result": "^29.5.0", + "@jest/transform": "^29.5.0", + "@jest/types": "^29.5.0", + "@jridgewell/trace-mapping": "^0.3.15", + "@types/node": "*", + "chalk": "^4.0.0", + "collect-v8-coverage": "^1.0.0", + "exit": "^0.1.2", + "glob": "^7.1.3", + "graceful-fs": "^4.2.9", + "istanbul-lib-coverage": "^3.0.0", + "istanbul-lib-instrument": "^5.1.0", + "istanbul-lib-report": "^3.0.0", + "istanbul-lib-source-maps": "^4.0.0", + "istanbul-reports": "^3.1.3", + "jest-message-util": "^29.5.0", + "jest-util": "^29.5.0", + "jest-worker": "^29.5.0", + "slash": "^3.0.0", + "string-length": "^4.0.1", + "strip-ansi": "^6.0.0", + "v8-to-istanbul": "^9.0.1" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "peerDependencies": { + "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0" + }, + "peerDependenciesMeta": { + "node-notifier": { + "optional": true + } + } + }, + "node_modules/@jest/schemas": { + "version": "29.4.3", + "dev": true, + "license": "MIT", + "dependencies": { + "@sinclair/typebox": "^0.25.16" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@jest/source-map": { + "version": "29.4.3", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/trace-mapping": "^0.3.15", + "callsites": "^3.0.0", + "graceful-fs": "^4.2.9" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@jest/test-result": { + "version": "29.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@jest/console": "^29.5.0", + "@jest/types": "^29.5.0", + "@types/istanbul-lib-coverage": "^2.0.0", + "collect-v8-coverage": "^1.0.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@jest/test-sequencer": { + "version": "29.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@jest/test-result": "^29.5.0", + "graceful-fs": "^4.2.9", + "jest-haste-map": "^29.5.0", + "slash": "^3.0.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@jest/transform": { + "version": "29.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/core": "^7.11.6", + "@jest/types": "^29.5.0", + "@jridgewell/trace-mapping": "^0.3.15", + "babel-plugin-istanbul": "^6.1.1", + "chalk": "^4.0.0", + "convert-source-map": "^2.0.0", + "fast-json-stable-stringify": "^2.1.0", + "graceful-fs": "^4.2.9", + "jest-haste-map": "^29.5.0", + "jest-regex-util": "^29.4.3", + "jest-util": "^29.5.0", + "micromatch": "^4.0.4", + "pirates": "^4.0.4", + "slash": "^3.0.0", + "write-file-atomic": "^4.0.2" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@jest/transform/node_modules/convert-source-map": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz", + "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==", + "dev": true, + "license": "MIT" + }, + "node_modules/@jest/types": { + "version": "29.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@jest/schemas": "^29.4.3", + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^17.0.8", + "chalk": "^4.0.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@jridgewell/gen-mapping": { + "version": "0.3.3", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.3.tgz", + "integrity": "sha512-HLhSWOLRi875zjjMG/r+Nv0oCW8umGb0BgEhyX3dDX3egwZtB8PqLnjz3yedt8R5StBrzcg4aBpnh8UA9D1BoQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/set-array": "^1.0.1", + "@jridgewell/sourcemap-codec": "^1.4.10", + "@jridgewell/trace-mapping": "^0.3.9" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/gen-mapping/node_modules/@jridgewell/sourcemap-codec": { + "version": "1.4.15", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz", + "integrity": "sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg==", + "dev": true, + "license": "MIT" + }, + "node_modules/@jridgewell/resolve-uri": { + "version": "3.1.0", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/set-array": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.1.2.tgz", + "integrity": "sha512-xnkseuNADM0gt2bs+BvhO0p78Mk762YnZdsuzFV018NoG1Sj1SCQvpSqa7XUaTam5vAGasABV9qXASMKnFMwMw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.4.14", + "dev": true, + "license": "MIT" + }, + "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.18", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/resolve-uri": "3.1.0", + "@jridgewell/sourcemap-codec": "1.4.14" + } + }, + "node_modules/@microsoft/tsdoc": { + "version": "0.14.2", + "resolved": "https://registry.npmjs.org/@microsoft/tsdoc/-/tsdoc-0.14.2.tgz", + "integrity": "sha512-9b8mPpKrfeGRuhFH5iO1iwCLeIIsV6+H1sRfxbkoGXIyQE2BTsPd9zqSqQJ+pv5sJ/hT5M1zvOFL02MnEezFug==" + }, + "node_modules/@nodelib/fs.scandir": { + "version": "2.1.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", + "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==", + "license": "MIT", + "dependencies": { + "@nodelib/fs.stat": "2.0.5", + "run-parallel": "^1.1.9" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nodelib/fs.stat": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz", + "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==", + "license": "MIT", + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nodelib/fs.walk": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz", + "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==", + "license": "MIT", + "dependencies": { + "@nodelib/fs.scandir": "2.1.5", + "fastq": "^1.6.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@sinclair/typebox": { + "version": "0.25.24", + "dev": true, + "license": "MIT" + }, + "node_modules/@sinonjs/commons": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/@sinonjs/commons/-/commons-3.0.0.tgz", + "integrity": "sha512-jXBtWAF4vmdNmZgD5FoKsVLv3rPgDnLgPbU84LIJ3otV44vJlDRokVng5v8NFJdCf/da9legHcKaRuZs4L7faA==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "type-detect": "4.0.8" + } + }, + "node_modules/@sinonjs/fake-timers": { + "version": "10.3.0", + "resolved": "https://registry.npmjs.org/@sinonjs/fake-timers/-/fake-timers-10.3.0.tgz", + "integrity": "sha512-V4BG07kuYSUkTCSBHG8G8TNhM+F19jXFWnQtzj+we8DrkpSBCee9Z3Ms8yiGer/dlmhe35/Xdgyo3/0rQKg7YA==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "@sinonjs/commons": "^3.0.0" + } + }, + "node_modules/@ts-morph/common": { + "version": "0.21.0", + "resolved": "https://registry.npmjs.org/@ts-morph/common/-/common-0.21.0.tgz", + "integrity": "sha512-ES110Mmne5Vi4ypUKrtVQfXFDtCsDXiUiGxF6ILVlE90dDD4fdpC1LSjydl/ml7xJWKSDZwUYD2zkOePMSrPBA==", + "dependencies": { + "fast-glob": "^3.2.12", + "minimatch": "^7.4.3", + "mkdirp": "^2.1.6", + "path-browserify": "^1.0.1" + } + }, + "node_modules/@ts-morph/common/node_modules/brace-expansion": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", + "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", + "dependencies": { + "balanced-match": "^1.0.0" + } + }, + "node_modules/@ts-morph/common/node_modules/minimatch": { + "version": "7.4.6", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-7.4.6.tgz", + "integrity": "sha512-sBz8G/YjVniEz6lKPNpKxXwazJe4c19fEfV2GDMX6AjFz+MX9uDWIZW8XreVhkFW3fkIdTv/gxWr/Kks5FFAVw==", + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/@types/babel__core": { + "version": "7.20.1", + "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.1.tgz", + "integrity": "sha512-aACu/U/omhdk15O4Nfb+fHgH/z3QsfQzpnvRZhYhThms83ZnAOZz7zZAWO7mn2yyNQaA4xTO8GLK3uqFU4bYYw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.20.7", + "@babel/types": "^7.20.7", + "@types/babel__generator": "*", + "@types/babel__template": "*", + "@types/babel__traverse": "*" + } + }, + "node_modules/@types/babel__generator": { + "version": "7.6.4", + "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.6.4.tgz", + "integrity": "sha512-tFkciB9j2K755yrTALxD44McOrk+gfpIpvC3sxHjRawj6PfnQxrse4Clq5y/Rq+G3mrBurMax/lG8Qn2t9mSsg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.0.0" + } + }, + "node_modules/@types/babel__template": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.1.tgz", + "integrity": "sha512-azBFKemX6kMg5Io+/rdGT0dkGreboUVR0Cdm3fz9QJWpaQGJRQXl7C+6hOTCZcMll7KFyEQpgbYI2lHdsS4U7g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.1.0", + "@babel/types": "^7.0.0" + } + }, + "node_modules/@types/babel__traverse": { + "version": "7.20.1", + "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.20.1.tgz", + "integrity": "sha512-MitHFXnhtgwsGZWtT68URpOvLN4EREih1u3QtQiN4VdAxWKRVvGCSvw/Qth0M0Qq3pJpnGOu5JaM/ydK7OGbqg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.20.7" + } + }, + "node_modules/@types/graceful-fs": { + "version": "4.1.6", + "resolved": "https://registry.npmjs.org/@types/graceful-fs/-/graceful-fs-4.1.6.tgz", + "integrity": "sha512-Sig0SNORX9fdW+bQuTEovKj3uHcUL6LQKbCrrqb1X7J6/ReAbhCXRAhc+SMejhLELFj2QcyuxmUooZ4bt5ReSw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/istanbul-lib-coverage": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.4.tgz", + "integrity": "sha512-z/QT1XN4K4KYuslS23k62yDIDLwLFkzxOuMplDtObz0+y7VqJCaO2o+SPwHCvLFZh7xazvvoor2tA/hPz9ee7g==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/istanbul-lib-report": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/@types/istanbul-lib-report/-/istanbul-lib-report-3.0.0.tgz", + "integrity": "sha512-plGgXAPfVKFoYfa9NpYDAkseG+g6Jr294RqeqcqDixSbU34MZVJRi/P+7Y8GDpzkEwLaGZZOpKIEmeVZNtKsrg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/istanbul-lib-coverage": "*" + } + }, + "node_modules/@types/istanbul-reports": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/@types/istanbul-reports/-/istanbul-reports-3.0.1.tgz", + "integrity": "sha512-c3mAZEuK0lvBp8tmuL74XRKn1+y2dcwOUpH7x4WrF6gk1GIgiluDRgMYQtw2OFcBvAJWlt6ASU3tSqxp0Uu0Aw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/istanbul-lib-report": "*" + } + }, + "node_modules/@types/json-schema": { + "version": "7.0.12", + "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.12.tgz", + "integrity": "sha512-Hr5Jfhc9eYOQNPYO5WLDq/n4jqijdHNlDXjuAQkkt+mWdQR+XJToOHrsD4cPaMXpn6KO7y2+wM8AZEs8VpBLVA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/json5": { + "version": "0.0.29", + "resolved": "https://registry.npmjs.org/@types/json5/-/json5-0.0.29.tgz", + "integrity": "sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/node": { + "version": "20.3.1", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/prettier": { + "version": "2.7.3", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/semver": { + "version": "7.5.0", + "resolved": "https://registry.npmjs.org/@types/semver/-/semver-7.5.0.tgz", + "integrity": "sha512-G8hZ6XJiHnuhQKR7ZmysCeJWE08o8T0AXtk5darsCaTVsYZhhgUrq53jizaR2FvsoeCwJhlmwTjkXBY5Pn/ZHw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/stack-utils": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/@types/stack-utils/-/stack-utils-2.0.1.tgz", + "integrity": "sha512-Hl219/BT5fLAaz6NDkSuhzasy49dwQS/DSdu4MdggFB8zcXv7vflBI3xp7FEmkmdDkBUI2bPUNeMttp2knYdxw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/yargs": { + "version": "17.0.24", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-17.0.24.tgz", + "integrity": "sha512-6i0aC7jV6QzQB8ne1joVZ0eSFIstHsCrobmOtghM11yGlH0j43FKL2UhWdELkyps0zuf7qVTUVCCR+tgSlyLLw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/yargs-parser": "*" + } + }, + "node_modules/@types/yargs-parser": { + "version": "21.0.0", + "resolved": "https://registry.npmjs.org/@types/yargs-parser/-/yargs-parser-21.0.0.tgz", + "integrity": "sha512-iO9ZQHkZxHn4mSakYV0vFHAVDyEOIJQrV2uZ06HxEPcx+mt8swXoZHIbaaJ2crJYFfErySgktuTZ3BeLz+XmFA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@typescript-eslint/eslint-plugin": { + "version": "5.60.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@eslint-community/regexpp": "^4.4.0", + "@typescript-eslint/scope-manager": "5.60.0", + "@typescript-eslint/type-utils": "5.60.0", + "@typescript-eslint/utils": "5.60.0", + "debug": "^4.3.4", + "grapheme-splitter": "^1.0.4", + "ignore": "^5.2.0", + "natural-compare-lite": "^1.4.0", + "semver": "^7.3.7", + "tsutils": "^3.21.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "@typescript-eslint/parser": "^5.0.0", + "eslint": "^6.0.0 || ^7.0.0 || ^8.0.0" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/@typescript-eslint/eslint-plugin/node_modules/semver": { + "version": "7.5.2", + "dev": true, + "license": "ISC", + "dependencies": { + "lru-cache": "^6.0.0" + }, + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/@typescript-eslint/parser": { + "version": "5.60.0", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "@typescript-eslint/scope-manager": "5.60.0", + "@typescript-eslint/types": "5.60.0", + "@typescript-eslint/typescript-estree": "5.60.0", + "debug": "^4.3.4" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^6.0.0 || ^7.0.0 || ^8.0.0" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/@typescript-eslint/scope-manager": { + "version": "5.60.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/types": "5.60.0", + "@typescript-eslint/visitor-keys": "5.60.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/@typescript-eslint/type-utils": { + "version": "5.60.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/typescript-estree": "5.60.0", + "@typescript-eslint/utils": "5.60.0", + "debug": "^4.3.4", + "tsutils": "^3.21.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "*" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/@typescript-eslint/types": { + "version": "5.60.0", + "dev": true, + "license": "MIT", + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/@typescript-eslint/typescript-estree": { + "version": "5.60.0", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "@typescript-eslint/types": "5.60.0", + "@typescript-eslint/visitor-keys": "5.60.0", + "debug": "^4.3.4", + "globby": "^11.1.0", + "is-glob": "^4.0.3", + "semver": "^7.3.7", + "tsutils": "^3.21.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/@typescript-eslint/typescript-estree/node_modules/semver": { + "version": "7.5.2", + "dev": true, + "license": "ISC", + "dependencies": { + "lru-cache": "^6.0.0" + }, + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/@typescript-eslint/utils": { + "version": "5.60.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@eslint-community/eslint-utils": "^4.2.0", + "@types/json-schema": "^7.0.9", + "@types/semver": "^7.3.12", + "@typescript-eslint/scope-manager": "5.60.0", + "@typescript-eslint/types": "5.60.0", + "@typescript-eslint/typescript-estree": "5.60.0", + "eslint-scope": "^5.1.1", + "semver": "^7.3.7" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, + "node_modules/@typescript-eslint/utils/node_modules/eslint-scope": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-5.1.1.tgz", + "integrity": "sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "esrecurse": "^4.3.0", + "estraverse": "^4.1.1" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/@typescript-eslint/utils/node_modules/estraverse": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz", + "integrity": "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">=4.0" + } + }, + "node_modules/@typescript-eslint/utils/node_modules/semver": { + "version": "7.5.2", + "dev": true, + "license": "ISC", + "dependencies": { + "lru-cache": "^6.0.0" + }, + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/@typescript-eslint/visitor-keys": { + "version": "5.60.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/types": "5.60.0", + "eslint-visitor-keys": "^3.3.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/acorn": { + "version": "8.9.0", + "dev": true, + "license": "MIT", + "bin": { + "acorn": "bin/acorn" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/acorn-jsx": { + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz", + "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, + "node_modules/ajv": { + "version": "6.12.6", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz", + "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==", + "dev": true, + "license": "MIT", + "dependencies": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/algo-msgpack-with-bigint": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/algo-msgpack-with-bigint/-/algo-msgpack-with-bigint-2.1.1.tgz", + "integrity": "sha512-F1tGh056XczEaEAqu7s+hlZUDWwOBT70Eq0lfMpBP2YguSQVyxRbprLq5rELXKQOyOaixTWYhMeMQMzP0U5FoQ==", + "license": "ISC", + "engines": { + "node": ">= 10" + } + }, + "node_modules/algosdk": { + "version": "2.7.0", + "resolved": "https://registry.npmjs.org/algosdk/-/algosdk-2.7.0.tgz", + "integrity": "sha512-sBE9lpV7bup3rZ+q2j3JQaFAE9JwZvjWKX00vPlG8e9txctXbgLL56jZhSWZndqhDI9oI+0P4NldkuQIWdrUyg==", + "dependencies": { + "algo-msgpack-with-bigint": "^2.1.1", + "buffer": "^6.0.3", + "hi-base32": "^0.5.1", + "js-sha256": "^0.9.0", + "js-sha3": "^0.8.0", + "js-sha512": "^0.8.0", + "json-bigint": "^1.0.0", + "tweetnacl": "^1.0.3", + "vlq": "^2.0.4" + }, + "engines": { + "node": ">=18.0.0" + } + }, + "node_modules/ansi-escapes": { + "version": "4.3.2", + "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.2.tgz", + "integrity": "sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "type-fest": "^0.21.3" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/ansi-escapes/node_modules/type-fest": { + "version": "0.21.3", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.21.3.tgz", + "integrity": "sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==", + "dev": true, + "license": "(MIT OR CC0-1.0)", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/anymatch": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz", + "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==", + "dev": true, + "license": "ISC", + "dependencies": { + "normalize-path": "^3.0.0", + "picomatch": "^2.0.4" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/argparse": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", + "license": "Python-2.0" + }, + "node_modules/array-buffer-byte-length": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/array-buffer-byte-length/-/array-buffer-byte-length-1.0.0.tgz", + "integrity": "sha512-LPuwb2P+NrQw3XhxGc36+XSvuBPopovXYTR9Ew++Du9Yb/bx5AzBfrIsBoj0EZUifjQU+sHL21sseZ3jerWO/A==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.2", + "is-array-buffer": "^3.0.1" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/array-includes": { + "version": "3.1.6", + "resolved": "https://registry.npmjs.org/array-includes/-/array-includes-3.1.6.tgz", + "integrity": "sha512-sgTbLvL6cNnw24FnbaDyjmvddQ2ML8arZsgaJhoABMoplz/4QRhtrYS+alr1BUM1Bwp6dhx8vVCBSLG+StwOFw==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4", + "get-intrinsic": "^1.1.3", + "is-string": "^1.0.7" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/array-union": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz", + "integrity": "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/array.prototype.flat": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/array.prototype.flat/-/array.prototype.flat-1.3.1.tgz", + "integrity": "sha512-roTU0KWIOmJ4DRLmwKd19Otg0/mT3qPNt0Qb3GWW8iObuZXxrjB/pzn0R3hqpRSWg4HCwqx+0vwOnWnvlOyeIA==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4", + "es-shim-unscopables": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/array.prototype.flatmap": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/array.prototype.flatmap/-/array.prototype.flatmap-1.3.1.tgz", + "integrity": "sha512-8UGn9O1FDVvMNB0UlLv4voxRMze7+FpHyF5mSMRjWHUMlpoDViniy05870VlxhfgTnLbpuwTzvD76MTtWxB/mQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4", + "es-shim-unscopables": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/available-typed-arrays": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.5.tgz", + "integrity": "sha512-DMD0KiN46eipeziST1LPP/STfDU0sufISXmjSgvVsoU2tqxctQeASejWcfNtxYKqETM1UxQ8sp2OrSBWpHY6sw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/babel-jest": { + "version": "29.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@jest/transform": "^29.5.0", + "@types/babel__core": "^7.1.14", + "babel-plugin-istanbul": "^6.1.1", + "babel-preset-jest": "^29.5.0", + "chalk": "^4.0.0", + "graceful-fs": "^4.2.9", + "slash": "^3.0.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "peerDependencies": { + "@babel/core": "^7.8.0" + } + }, + "node_modules/babel-plugin-istanbul": { + "version": "6.1.1", + "resolved": "https://registry.npmjs.org/babel-plugin-istanbul/-/babel-plugin-istanbul-6.1.1.tgz", + "integrity": "sha512-Y1IQok9821cC9onCx5otgFfRm7Lm+I+wwxOx738M/WLPZ9Q42m4IG5W0FNX8WLL2gYMZo3JkuXIH2DOpWM+qwA==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "@babel/helper-plugin-utils": "^7.0.0", + "@istanbuljs/load-nyc-config": "^1.0.0", + "@istanbuljs/schema": "^0.1.2", + "istanbul-lib-instrument": "^5.0.4", + "test-exclude": "^6.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/babel-plugin-jest-hoist": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/babel-plugin-jest-hoist/-/babel-plugin-jest-hoist-29.5.0.tgz", + "integrity": "sha512-zSuuuAlTMT4mzLj2nPnUm6fsE6270vdOfnpbJ+RmruU75UhLFvL0N2NgI7xpeS7NaB6hGqmd5pVpGTDYvi4Q3w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/template": "^7.3.3", + "@babel/types": "^7.3.3", + "@types/babel__core": "^7.1.14", + "@types/babel__traverse": "^7.0.6" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/babel-preset-current-node-syntax": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/babel-preset-current-node-syntax/-/babel-preset-current-node-syntax-1.0.1.tgz", + "integrity": "sha512-M7LQ0bxarkxQoN+vz5aJPsLBn77n8QgTFmo8WK0/44auK2xlCXrYcUxHFxgU7qW5Yzw/CjmLRK2uJzaCd7LvqQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/plugin-syntax-async-generators": "^7.8.4", + "@babel/plugin-syntax-bigint": "^7.8.3", + "@babel/plugin-syntax-class-properties": "^7.8.3", + "@babel/plugin-syntax-import-meta": "^7.8.3", + "@babel/plugin-syntax-json-strings": "^7.8.3", + "@babel/plugin-syntax-logical-assignment-operators": "^7.8.3", + "@babel/plugin-syntax-nullish-coalescing-operator": "^7.8.3", + "@babel/plugin-syntax-numeric-separator": "^7.8.3", + "@babel/plugin-syntax-object-rest-spread": "^7.8.3", + "@babel/plugin-syntax-optional-catch-binding": "^7.8.3", + "@babel/plugin-syntax-optional-chaining": "^7.8.3", + "@babel/plugin-syntax-top-level-await": "^7.8.3" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/babel-preset-jest": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/babel-preset-jest/-/babel-preset-jest-29.5.0.tgz", + "integrity": "sha512-JOMloxOqdiBSxMAzjRaH023/vvcaSaec49zvg+2LmNsktC7ei39LTJGw02J+9uUtTZUq6xbLyJ4dxe9sSmIuAg==", + "dev": true, + "license": "MIT", + "dependencies": { + "babel-plugin-jest-hoist": "^29.5.0", + "babel-preset-current-node-syntax": "^1.0.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/balanced-match": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", + "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==", + "license": "MIT" + }, + "node_modules/base64-js": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz", + "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT" + }, + "node_modules/bignumber.js": { + "version": "9.1.1", + "resolved": "https://registry.npmjs.org/bignumber.js/-/bignumber.js-9.1.1.tgz", + "integrity": "sha512-pHm4LsMJ6lzgNGVfZHjMoO8sdoRhOzOH4MLmY65Jg70bpxCKu5iOHNJyfF6OyvYw7t8Fpf35RuzUyqnQsj8Vig==", + "license": "MIT", + "engines": { + "node": "*" + } + }, + "node_modules/brace-expansion": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", + "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "node_modules/braces": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz", + "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==", + "license": "MIT", + "dependencies": { + "fill-range": "^7.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/browserslist": { + "version": "4.21.9", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "caniuse-lite": "^1.0.30001503", + "electron-to-chromium": "^1.4.431", + "node-releases": "^2.0.12", + "update-browserslist-db": "^1.0.11" + }, + "bin": { + "browserslist": "cli.js" + }, + "engines": { + "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7" + } + }, + "node_modules/bs-logger": { + "version": "0.2.6", + "resolved": "https://registry.npmjs.org/bs-logger/-/bs-logger-0.2.6.tgz", + "integrity": "sha512-pd8DCoxmbgc7hyPKOvxtqNcjYoOsABPQdcCUjGp3d42VR2CX1ORhk2A87oqqu5R1kk+76nsxZupkmyd+MVtCog==", + "dev": true, + "license": "MIT", + "dependencies": { + "fast-json-stable-stringify": "2.x" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/bser": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/bser/-/bser-2.1.1.tgz", + "integrity": "sha512-gQxTNE/GAfIIrmHLUE3oJyp5FO6HRBfhjnw4/wMmA63ZGDJnWBmgY/lyQBpnDUkGmAhbSe39tx2d/iTOAfglwQ==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "node-int64": "^0.4.0" + } + }, + "node_modules/buffer": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/buffer/-/buffer-6.0.3.tgz", + "integrity": "sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT", + "dependencies": { + "base64-js": "^1.3.1", + "ieee754": "^1.2.1" + } + }, + "node_modules/buffer-from": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz", + "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/call-bind": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.2.tgz", + "integrity": "sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==", + "dev": true, + "license": "MIT", + "dependencies": { + "function-bind": "^1.1.1", + "get-intrinsic": "^1.0.2" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/callsites": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz", + "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/camel-case": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/camel-case/-/camel-case-4.1.2.tgz", + "integrity": "sha512-gxGWBrTT1JuMx6R+o5PTXMmUnhnVzLQ9SNutD4YqKtI6ap897t3tKECYla6gCWEkplXnlNybEkZg9GEGxKFCgw==", + "dev": true, + "license": "MIT", + "dependencies": { + "pascal-case": "^3.1.2", + "tslib": "^2.0.3" + } + }, + "node_modules/camelcase": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz", + "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/caniuse-lite": { + "version": "1.0.30001505", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/caniuse-lite" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "CC-BY-4.0" + }, + "node_modules/capital-case": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/capital-case/-/capital-case-1.0.4.tgz", + "integrity": "sha512-ds37W8CytHgwnhGGTi88pcPyR15qoNkOpYwmMMfnWqqWgESapLqvDx6huFjQ5vqWSn2Z06173XNA7LtMOeUh1A==", + "dev": true, + "license": "MIT", + "dependencies": { + "no-case": "^3.0.4", + "tslib": "^2.0.3", + "upper-case-first": "^2.0.2" + } + }, + "node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/change-case": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/change-case/-/change-case-4.1.2.tgz", + "integrity": "sha512-bSxY2ws9OtviILG1EiY5K7NNxkqg/JnRnFxLtKQ96JaviiIxi7djMrSd0ECT9AC+lttClmYwKw53BWpOMblo7A==", + "dev": true, + "license": "MIT", + "dependencies": { + "camel-case": "^4.1.2", + "capital-case": "^1.0.4", + "constant-case": "^3.0.4", + "dot-case": "^3.0.4", + "header-case": "^2.0.4", + "no-case": "^3.0.4", + "param-case": "^3.0.4", + "pascal-case": "^3.1.2", + "path-case": "^3.0.4", + "sentence-case": "^3.0.4", + "snake-case": "^3.0.4", + "tslib": "^2.0.3" + } + }, + "node_modules/char-regex": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/char-regex/-/char-regex-1.0.2.tgz", + "integrity": "sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + } + }, + "node_modules/ci-info": { + "version": "3.8.0", + "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-3.8.0.tgz", + "integrity": "sha512-eXTggHWSooYhq49F2opQhuHWgzucfF2YgODK4e1566GQs5BIfP30B0oenwBJHfWxAs2fyPB1s7Mg949zLf61Yw==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/sibiraj-s" + } + ], + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/cjs-module-lexer": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/cjs-module-lexer/-/cjs-module-lexer-1.2.3.tgz", + "integrity": "sha512-0TNiGstbQmCFwt4akjjBg5pLRTSyj/PkWQ1ZoO2zntmg9yLqSRxwEa4iCfQLGjqhiqBfOJa7W/E8wfGrTDmlZQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/cliui": { + "version": "8.0.1", + "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz", + "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==", + "dev": true, + "license": "ISC", + "dependencies": { + "string-width": "^4.2.0", + "strip-ansi": "^6.0.1", + "wrap-ansi": "^7.0.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/co": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/co/-/co-4.6.0.tgz", + "integrity": "sha512-QVb0dM5HvG+uaxitm8wONl7jltx8dqhfU33DcqtOZcLSVIKSDDLDi7+0LbAKiyI8hD9u42m2YxXSkMGWThaecQ==", + "dev": true, + "license": "MIT", + "engines": { + "iojs": ">= 1.0.0", + "node": ">= 0.12.0" + } + }, + "node_modules/code-block-writer": { + "version": "12.0.0", + "resolved": "https://registry.npmjs.org/code-block-writer/-/code-block-writer-12.0.0.tgz", + "integrity": "sha512-q4dMFMlXtKR3XNBHyMHt/3pwYNA69EDk00lloMOaaUMKPUXBw6lpXtbu3MMVG6/uOihGnRDOlkyqsONEUj60+w==" + }, + "node_modules/collect-v8-coverage": { + "version": "1.0.1", + "dev": true, + "license": "MIT" + }, + "node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true, + "license": "MIT" + }, + "node_modules/commander": { + "version": "10.0.1", + "resolved": "https://registry.npmjs.org/commander/-/commander-10.0.1.tgz", + "integrity": "sha512-y4Mg2tXshplEbSGzx7amzPwKKOCGuoSRP/CjEdwwk0FOGlUbq6lKuoyDZTNZkmxHdJtp54hdfY/JUrdL7Xfdug==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=14" + } + }, + "node_modules/concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==", + "dev": true, + "license": "MIT" + }, + "node_modules/confusing-browser-globals": { + "version": "1.0.11", + "resolved": "https://registry.npmjs.org/confusing-browser-globals/-/confusing-browser-globals-1.0.11.tgz", + "integrity": "sha512-JsPKdmh8ZkmnHxDk55FZ1TqVLvEQTvoByJZRN9jzI0UjxK/QgAmsphz7PGtqgPieQZ/CQcHWXCR7ATDNhGe+YA==", + "dev": true, + "license": "MIT" + }, + "node_modules/constant-case": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/constant-case/-/constant-case-3.0.4.tgz", + "integrity": "sha512-I2hSBi7Vvs7BEuJDr5dDHfzb/Ruj3FyvFyh7KLilAjNQw3Be+xgqUBA2W6scVEcL0hL1dwPRtIqEPVUCKkSsyQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "no-case": "^3.0.4", + "tslib": "^2.0.3", + "upper-case": "^2.0.2" + } + }, + "node_modules/convert-source-map": { + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.9.0.tgz", + "integrity": "sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==", + "dev": true, + "license": "MIT" + }, + "node_modules/cross-spawn": { + "version": "7.0.3", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz", + "integrity": "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==", + "dev": true, + "license": "MIT", + "dependencies": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/debug": { + "version": "4.3.4", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz", + "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "ms": "2.1.2" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/dedent": { + "version": "0.7.0", + "dev": true, + "license": "MIT" + }, + "node_modules/deep-is": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz", + "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/deepmerge": { + "version": "4.3.1", + "resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-4.3.1.tgz", + "integrity": "sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/define-properties": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.0.tgz", + "integrity": "sha512-xvqAVKGfT1+UAvPwKTVw/njhdQ8ZhXK4lI0bCIuCMrp2up9nPnaDftrLtmpTazqd1o+UY4zgzU+avtMbDP+ldA==", + "dev": true, + "license": "MIT", + "dependencies": { + "has-property-descriptors": "^1.0.0", + "object-keys": "^1.1.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/detect-newline": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/detect-newline/-/detect-newline-3.1.0.tgz", + "integrity": "sha512-TLz+x/vEXm/Y7P7wn1EJFNLxYpUD4TgMosxY6fAVJUnJMbupHBOncxyWUG9OpTaH9EBD7uFI5LfEgmMOc54DsA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/diff-sequences": { + "version": "29.4.3", + "resolved": "https://registry.npmjs.org/diff-sequences/-/diff-sequences-29.4.3.tgz", + "integrity": "sha512-ofrBgwpPhCD85kMKtE9RYFFq6OC1A89oW2vvgWZNCwxrUpRUILopY7lsYyMDSjc8g6U6aiO0Qubg6r4Wgt5ZnA==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/dir-glob": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz", + "integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==", + "dev": true, + "license": "MIT", + "dependencies": { + "path-type": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/doctrine": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-2.1.0.tgz", + "integrity": "sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "esutils": "^2.0.2" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/dot-case": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/dot-case/-/dot-case-3.0.4.tgz", + "integrity": "sha512-Kv5nKlh6yRrdrGvxeJ2e5y2eRUpkUosIW4A2AS38zwSz27zu7ufDwQPi5Jhs3XAlGNetl3bmnGhQsMtkKJnj3w==", + "dev": true, + "license": "MIT", + "dependencies": { + "no-case": "^3.0.4", + "tslib": "^2.0.3" + } + }, + "node_modules/dotenv": { + "version": "16.3.1", + "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.3.1.tgz", + "integrity": "sha512-IPzF4w4/Rd94bA9imS68tZBaYyBWSCE47V1RGuMrB94iyTOIEwRmVL2x/4An+6mETpLrKJ5hQkB8W4kFAadeIQ==", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/motdotla/dotenv?sponsor=1" + } + }, + "node_modules/electron-to-chromium": { + "version": "1.4.435", + "dev": true, + "license": "ISC" + }, + "node_modules/emittery": { + "version": "0.13.1", + "resolved": "https://registry.npmjs.org/emittery/-/emittery-0.13.1.tgz", + "integrity": "sha512-DeWwawk6r5yR9jFgnDKYt4sLS0LmHJJi3ZOnb5/JdbYwj3nW+FxQnHIjhBKz8YLC7oRNPVM9NQ47I3CVx34eqQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sindresorhus/emittery?sponsor=1" + } + }, + "node_modules/emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "dev": true, + "license": "MIT" + }, + "node_modules/error-ex": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz", + "integrity": "sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-arrayish": "^0.2.1" + } + }, + "node_modules/es-abstract": { + "version": "1.21.2", + "dev": true, + "license": "MIT", + "dependencies": { + "array-buffer-byte-length": "^1.0.0", + "available-typed-arrays": "^1.0.5", + "call-bind": "^1.0.2", + "es-set-tostringtag": "^2.0.1", + "es-to-primitive": "^1.2.1", + "function.prototype.name": "^1.1.5", + "get-intrinsic": "^1.2.0", + "get-symbol-description": "^1.0.0", + "globalthis": "^1.0.3", + "gopd": "^1.0.1", + "has": "^1.0.3", + "has-property-descriptors": "^1.0.0", + "has-proto": "^1.0.1", + "has-symbols": "^1.0.3", + "internal-slot": "^1.0.5", + "is-array-buffer": "^3.0.2", + "is-callable": "^1.2.7", + "is-negative-zero": "^2.0.2", + "is-regex": "^1.1.4", + "is-shared-array-buffer": "^1.0.2", + "is-string": "^1.0.7", + "is-typed-array": "^1.1.10", + "is-weakref": "^1.0.2", + "object-inspect": "^1.12.3", + "object-keys": "^1.1.1", + "object.assign": "^4.1.4", + "regexp.prototype.flags": "^1.4.3", + "safe-regex-test": "^1.0.0", + "string.prototype.trim": "^1.2.7", + "string.prototype.trimend": "^1.0.6", + "string.prototype.trimstart": "^1.0.6", + "typed-array-length": "^1.0.4", + "unbox-primitive": "^1.0.2", + "which-typed-array": "^1.1.9" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/es-set-tostringtag": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.0.1.tgz", + "integrity": "sha512-g3OMbtlwY3QewlqAiMLI47KywjWZoEytKr8pf6iTC8uJq5bIAH52Z9pnQ8pVL6whrCto53JZDuUIsifGeLorTg==", + "dev": true, + "license": "MIT", + "dependencies": { + "get-intrinsic": "^1.1.3", + "has": "^1.0.3", + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-shim-unscopables": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/es-shim-unscopables/-/es-shim-unscopables-1.0.0.tgz", + "integrity": "sha512-Jm6GPcCdC30eMLbZ2x8z2WuRwAws3zTBBKuusffYVUrNj/GVSUAZ+xKMaUpfNDR5IbyNA5LJbaecoUVbmUcB1w==", + "dev": true, + "license": "MIT", + "dependencies": { + "has": "^1.0.3" + } + }, + "node_modules/es-to-primitive": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.2.1.tgz", + "integrity": "sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-callable": "^1.1.4", + "is-date-object": "^1.0.1", + "is-symbol": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/escalade": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz", + "integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/escape-string-regexp": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", + "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/eslint": { + "version": "8.43.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@eslint-community/eslint-utils": "^4.2.0", + "@eslint-community/regexpp": "^4.4.0", + "@eslint/eslintrc": "^2.0.3", + "@eslint/js": "8.43.0", + "@humanwhocodes/config-array": "^0.11.10", + "@humanwhocodes/module-importer": "^1.0.1", + "@nodelib/fs.walk": "^1.2.8", + "ajv": "^6.10.0", + "chalk": "^4.0.0", + "cross-spawn": "^7.0.2", + "debug": "^4.3.2", + "doctrine": "^3.0.0", + "escape-string-regexp": "^4.0.0", + "eslint-scope": "^7.2.0", + "eslint-visitor-keys": "^3.4.1", + "espree": "^9.5.2", + "esquery": "^1.4.2", + "esutils": "^2.0.2", + "fast-deep-equal": "^3.1.3", + "file-entry-cache": "^6.0.1", + "find-up": "^5.0.0", + "glob-parent": "^6.0.2", + "globals": "^13.19.0", + "graphemer": "^1.4.0", + "ignore": "^5.2.0", + "import-fresh": "^3.0.0", + "imurmurhash": "^0.1.4", + "is-glob": "^4.0.0", + "is-path-inside": "^3.0.3", + "js-yaml": "^4.1.0", + "json-stable-stringify-without-jsonify": "^1.0.1", + "levn": "^0.4.1", + "lodash.merge": "^4.6.2", + "minimatch": "^3.1.2", + "natural-compare": "^1.4.0", + "optionator": "^0.9.1", + "strip-ansi": "^6.0.1", + "strip-json-comments": "^3.1.0", + "text-table": "^0.2.0" + }, + "bin": { + "eslint": "bin/eslint.js" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/eslint-config-airbnb-base": { + "version": "15.0.0", + "resolved": "https://registry.npmjs.org/eslint-config-airbnb-base/-/eslint-config-airbnb-base-15.0.0.tgz", + "integrity": "sha512-xaX3z4ZZIcFLvh2oUNvcX5oEofXda7giYmuplVxoOg5A7EXJMrUyqRgR+mhDhPK8LZ4PttFOBvCYDbX3sUoUig==", + "dev": true, + "license": "MIT", + "dependencies": { + "confusing-browser-globals": "^1.0.10", + "object.assign": "^4.1.2", + "object.entries": "^1.1.5", + "semver": "^6.3.0" + }, + "engines": { + "node": "^10.12.0 || >=12.0.0" + }, + "peerDependencies": { + "eslint": "^7.32.0 || ^8.2.0", + "eslint-plugin-import": "^2.25.2" + } + }, + "node_modules/eslint-config-airbnb-typescript": { + "version": "17.0.0", + "dev": true, + "license": "MIT", + "dependencies": { + "eslint-config-airbnb-base": "^15.0.0" + }, + "peerDependencies": { + "@typescript-eslint/eslint-plugin": "^5.13.0", + "@typescript-eslint/parser": "^5.0.0", + "eslint": "^7.32.0 || ^8.2.0", + "eslint-plugin-import": "^2.25.3" + } + }, + "node_modules/eslint-import-resolver-node": { + "version": "0.3.7", + "dev": true, + "license": "MIT", + "dependencies": { + "debug": "^3.2.7", + "is-core-module": "^2.11.0", + "resolve": "^1.22.1" + } + }, + "node_modules/eslint-import-resolver-node/node_modules/debug": { + "version": "3.2.7", + "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz", + "integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "ms": "^2.1.1" + } + }, + "node_modules/eslint-import-resolver-node/node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "dev": true, + "license": "MIT" + }, + "node_modules/eslint-module-utils": { + "version": "2.8.0", + "dev": true, + "license": "MIT", + "dependencies": { + "debug": "^3.2.7" + }, + "engines": { + "node": ">=4" + }, + "peerDependenciesMeta": { + "eslint": { + "optional": true + } + } + }, + "node_modules/eslint-module-utils/node_modules/debug": { + "version": "3.2.7", + "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz", + "integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "ms": "^2.1.1" + } + }, + "node_modules/eslint-module-utils/node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "dev": true, + "license": "MIT" + }, + "node_modules/eslint-plugin-import": { + "version": "2.27.5", + "dev": true, + "license": "MIT", + "dependencies": { + "array-includes": "^3.1.6", + "array.prototype.flat": "^1.3.1", + "array.prototype.flatmap": "^1.3.1", + "debug": "^3.2.7", + "doctrine": "^2.1.0", + "eslint-import-resolver-node": "^0.3.7", + "eslint-module-utils": "^2.7.4", + "has": "^1.0.3", + "is-core-module": "^2.11.0", + "is-glob": "^4.0.3", + "minimatch": "^3.1.2", + "object.values": "^1.1.6", + "resolve": "^1.22.1", + "semver": "^6.3.0", + "tsconfig-paths": "^3.14.1" + }, + "engines": { + "node": ">=4" + }, + "peerDependencies": { + "eslint": "^2 || ^3 || ^4 || ^5 || ^6 || ^7.2.0 || ^8" + } + }, + "node_modules/eslint-plugin-import/node_modules/debug": { + "version": "3.2.7", + "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz", + "integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "ms": "^2.1.1" + } + }, + "node_modules/eslint-plugin-import/node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "dev": true, + "license": "MIT" + }, + "node_modules/eslint-scope": { + "version": "7.2.0", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "esrecurse": "^4.3.0", + "estraverse": "^5.2.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/eslint-visitor-keys": { + "version": "3.4.1", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/eslint/node_modules/doctrine": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz", + "integrity": "sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "esutils": "^2.0.2" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/eslint/node_modules/find-up": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", + "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", + "dev": true, + "license": "MIT", + "dependencies": { + "locate-path": "^6.0.0", + "path-exists": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/eslint/node_modules/locate-path": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", + "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", + "dev": true, + "license": "MIT", + "dependencies": { + "p-locate": "^5.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/eslint/node_modules/p-locate": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", + "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", + "dev": true, + "license": "MIT", + "dependencies": { + "p-limit": "^3.0.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/espree": { + "version": "9.5.2", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "acorn": "^8.8.0", + "acorn-jsx": "^5.3.2", + "eslint-visitor-keys": "^3.4.1" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/esprima": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz", + "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==", + "dev": true, + "license": "BSD-2-Clause", + "bin": { + "esparse": "bin/esparse.js", + "esvalidate": "bin/esvalidate.js" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/esquery": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.5.0.tgz", + "integrity": "sha512-YQLXUplAwJgCydQ78IMJywZCceoqk1oH01OERdSAJc/7U2AylwjhSCLDEtqwg811idIS/9fIU5GjG73IgjKMVg==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "estraverse": "^5.1.0" + }, + "engines": { + "node": ">=0.10" + } + }, + "node_modules/esrecurse": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz", + "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "estraverse": "^5.2.0" + }, + "engines": { + "node": ">=4.0" + } + }, + "node_modules/estraverse": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz", + "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">=4.0" + } + }, + "node_modules/esutils": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz", + "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/execa": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/execa/-/execa-5.1.1.tgz", + "integrity": "sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==", + "dev": true, + "license": "MIT", + "dependencies": { + "cross-spawn": "^7.0.3", + "get-stream": "^6.0.0", + "human-signals": "^2.1.0", + "is-stream": "^2.0.0", + "merge-stream": "^2.0.0", + "npm-run-path": "^4.0.1", + "onetime": "^5.1.2", + "signal-exit": "^3.0.3", + "strip-final-newline": "^2.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sindresorhus/execa?sponsor=1" + } + }, + "node_modules/exit": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/exit/-/exit-0.1.2.tgz", + "integrity": "sha512-Zk/eNKV2zbjpKzrsQ+n1G6poVbErQxJ0LBOJXaKZ1EViLzH+hrLu9cdXI4zw9dBQJslwBEpbQ2P1oS7nDxs6jQ==", + "dev": true, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/expect": { + "version": "29.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@jest/expect-utils": "^29.5.0", + "jest-get-type": "^29.4.3", + "jest-matcher-utils": "^29.5.0", + "jest-message-util": "^29.5.0", + "jest-util": "^29.5.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/fast-deep-equal": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", + "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/fast-glob": { + "version": "3.2.12", + "license": "MIT", + "dependencies": { + "@nodelib/fs.stat": "^2.0.2", + "@nodelib/fs.walk": "^1.2.3", + "glob-parent": "^5.1.2", + "merge2": "^1.3.0", + "micromatch": "^4.0.4" + }, + "engines": { + "node": ">=8.6.0" + } + }, + "node_modules/fast-glob/node_modules/glob-parent": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", + "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", + "license": "ISC", + "dependencies": { + "is-glob": "^4.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/fast-json-stable-stringify": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz", + "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==", + "dev": true, + "license": "MIT" + }, + "node_modules/fast-levenshtein": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz", + "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==", + "dev": true, + "license": "MIT" + }, + "node_modules/fastq": { + "version": "1.15.0", + "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.15.0.tgz", + "integrity": "sha512-wBrocU2LCXXa+lWBt8RoIRD89Fi8OdABODa/kEnyeyjS5aZO5/GNvI5sEINADqP/h8M29UHTHUb53sUu5Ihqdw==", + "license": "ISC", + "dependencies": { + "reusify": "^1.0.4" + } + }, + "node_modules/fb-watchman": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/fb-watchman/-/fb-watchman-2.0.2.tgz", + "integrity": "sha512-p5161BqbuCaSnB8jIbzQHOlpgsPmK5rJVDfDKO91Axs5NC1uu3HRQm6wt9cd9/+GtQQIO53JdGXXoyDpTAsgYA==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "bser": "2.1.1" + } + }, + "node_modules/file-entry-cache": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-6.0.1.tgz", + "integrity": "sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==", + "dev": true, + "license": "MIT", + "dependencies": { + "flat-cache": "^3.0.4" + }, + "engines": { + "node": "^10.12.0 || >=12.0.0" + } + }, + "node_modules/fill-range": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz", + "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==", + "license": "MIT", + "dependencies": { + "to-regex-range": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/find-up": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz", + "integrity": "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==", + "dev": true, + "license": "MIT", + "dependencies": { + "locate-path": "^5.0.0", + "path-exists": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/flat-cache": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-3.0.4.tgz", + "integrity": "sha512-dm9s5Pw7Jc0GvMYbshN6zchCA9RgQlzzEZX3vylR9IqFfS8XciblUXOKfW6SiuJ0e13eDYZoZV5wdrev7P3Nwg==", + "dev": true, + "license": "MIT", + "dependencies": { + "flatted": "^3.1.0", + "rimraf": "^3.0.2" + }, + "engines": { + "node": "^10.12.0 || >=12.0.0" + } + }, + "node_modules/flatted": { + "version": "3.2.7", + "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.2.7.tgz", + "integrity": "sha512-5nqDSxl8nn5BSNxyR3n4I6eDmbolI6WT+QqR547RwxQapgjQBmtktdP+HTBb/a/zLsbzERTONyUB5pefh5TtjQ==", + "dev": true, + "license": "ISC" + }, + "node_modules/for-each": { + "version": "0.3.3", + "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.3.tgz", + "integrity": "sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-callable": "^1.1.3" + } + }, + "node_modules/fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==", + "dev": true, + "license": "ISC" + }, + "node_modules/fsevents": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz", + "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==", + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/function-bind": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz", + "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==", + "dev": true, + "license": "MIT" + }, + "node_modules/function.prototype.name": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/function.prototype.name/-/function.prototype.name-1.1.5.tgz", + "integrity": "sha512-uN7m/BzVKQnCUF/iW8jYea67v++2u7m5UgENbHRtdDVclOUP+FMPlCNdmk0h/ysGyo2tavMJEDqJAkJdRa1vMA==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.3", + "es-abstract": "^1.19.0", + "functions-have-names": "^1.2.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/functions-have-names": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/functions-have-names/-/functions-have-names-1.2.3.tgz", + "integrity": "sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/gensync": { + "version": "1.0.0-beta.2", + "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz", + "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/get-caller-file": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz", + "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==", + "dev": true, + "license": "ISC", + "engines": { + "node": "6.* || 8.* || >= 10.*" + } + }, + "node_modules/get-intrinsic": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.1.tgz", + "integrity": "sha512-2DcsyfABl+gVHEfCOaTrWgyt+tb6MSEGmKq+kI5HwLbIYgjgmMcV8KQ41uaKz1xxUcn9tJtgFbQUEVcEbd0FYw==", + "dev": true, + "license": "MIT", + "dependencies": { + "function-bind": "^1.1.1", + "has": "^1.0.3", + "has-proto": "^1.0.1", + "has-symbols": "^1.0.3" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/get-package-type": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/get-package-type/-/get-package-type-0.1.0.tgz", + "integrity": "sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/get-stream": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-6.0.1.tgz", + "integrity": "sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/get-symbol-description": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/get-symbol-description/-/get-symbol-description-1.0.0.tgz", + "integrity": "sha512-2EmdH1YvIQiZpltCNgkuiUnyukzxM/R6NDJX31Ke3BG1Nq5b0S2PhX59UKi9vZpPDQVdqn+1IcaAwnzTT5vCjw==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.2", + "get-intrinsic": "^1.1.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/glob": { + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", + "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", + "dev": true, + "license": "ISC", + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.1.1", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + }, + "engines": { + "node": "*" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/glob-parent": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz", + "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==", + "dev": true, + "license": "ISC", + "dependencies": { + "is-glob": "^4.0.3" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/globals": { + "version": "13.20.0", + "dev": true, + "license": "MIT", + "dependencies": { + "type-fest": "^0.20.2" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/globalthis": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/globalthis/-/globalthis-1.0.3.tgz", + "integrity": "sha512-sFdI5LyBiNTHjRd7cGPWapiHWMOXKyuBNX/cWJ3NfzrZQVa8GI/8cofCl74AOVqq9W5kNmguTIzJ/1s2gyI9wA==", + "dev": true, + "license": "MIT", + "dependencies": { + "define-properties": "^1.1.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/globby": { + "version": "11.1.0", + "resolved": "https://registry.npmjs.org/globby/-/globby-11.1.0.tgz", + "integrity": "sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==", + "dev": true, + "license": "MIT", + "dependencies": { + "array-union": "^2.1.0", + "dir-glob": "^3.0.1", + "fast-glob": "^3.2.9", + "ignore": "^5.2.0", + "merge2": "^1.4.1", + "slash": "^3.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/gopd": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.0.1.tgz", + "integrity": "sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==", + "dev": true, + "license": "MIT", + "dependencies": { + "get-intrinsic": "^1.1.3" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/graceful-fs": { + "version": "4.2.11", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz", + "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==", + "dev": true, + "license": "ISC" + }, + "node_modules/grapheme-splitter": { + "version": "1.0.4", + "dev": true, + "license": "MIT" + }, + "node_modules/graphemer": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/graphemer/-/graphemer-1.4.0.tgz", + "integrity": "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==", + "dev": true, + "license": "MIT" + }, + "node_modules/has": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz", + "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==", + "dev": true, + "license": "MIT", + "dependencies": { + "function-bind": "^1.1.1" + }, + "engines": { + "node": ">= 0.4.0" + } + }, + "node_modules/has-bigints": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/has-bigints/-/has-bigints-1.0.2.tgz", + "integrity": "sha512-tSvCKtBr9lkF0Ex0aQiP9N+OpV4zi2r/Nee5VkRDbaqv35RLYMzbwQfFSZZH0kR+Rd6302UJZ2p/bJCEoR3VoQ==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/has-property-descriptors": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.0.tgz", + "integrity": "sha512-62DVLZGoiEBDHQyqG4w9xCuZ7eJEwNmJRWw2VY84Oedb7WFcA27fiEVe8oUQx9hAUJ4ekurquucTGwsyO1XGdQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "get-intrinsic": "^1.1.1" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.0.1.tgz", + "integrity": "sha512-7qE+iP+O+bgF9clE5+UoBFzE65mlBiVj3tKCrlNQ0Ogwm0BjpT/gK4SlLYDMybDh5I3TCTKnPPa0oMG7JDYrhg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-symbols": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz", + "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-tostringtag": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.0.tgz", + "integrity": "sha512-kFjcSNhnlGV1kyoGk7OXKSawH5JOb/LzUc5w9B02hOTO0dfFRjbHQKvg1d6cf3HbeUmtU9VbbV3qzZ2Teh97WQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "has-symbols": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/header-case": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/header-case/-/header-case-2.0.4.tgz", + "integrity": "sha512-H/vuk5TEEVZwrR0lp2zed9OCo1uAILMlx0JEMgC26rzyJJ3N1v6XkwHHXJQdR2doSjcGPM6OKPYoJgf0plJ11Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "capital-case": "^1.0.4", + "tslib": "^2.0.3" + } + }, + "node_modules/hi-base32": { + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/hi-base32/-/hi-base32-0.5.1.tgz", + "integrity": "sha512-EmBBpvdYh/4XxsnUybsPag6VikPYnN30td+vQk+GI3qpahVEG9+gTkG0aXVxTjBqQ5T6ijbWIu77O+C5WFWsnA==", + "license": "MIT" + }, + "node_modules/html-escaper": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz", + "integrity": "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==", + "dev": true, + "license": "MIT" + }, + "node_modules/human-signals": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-2.1.0.tgz", + "integrity": "sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=10.17.0" + } + }, + "node_modules/ieee754": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz", + "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "BSD-3-Clause" + }, + "node_modules/ignore": { + "version": "5.2.4", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.2.4.tgz", + "integrity": "sha512-MAb38BcSbH0eHNBxn7ql2NH/kX33OkB3lZ1BNdh7ENeRChHTYsTvWrMubiIAMNS2llXEEgZ1MUOBtXChP3kaFQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 4" + } + }, + "node_modules/import-fresh": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.0.tgz", + "integrity": "sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==", + "dev": true, + "license": "MIT", + "dependencies": { + "parent-module": "^1.0.0", + "resolve-from": "^4.0.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/import-fresh/node_modules/resolve-from": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz", + "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/import-local": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/import-local/-/import-local-3.1.0.tgz", + "integrity": "sha512-ASB07uLtnDs1o6EHjKpX34BKYDSqnFerfTOJL2HvMqF70LnxpjkzDB8J44oT9pu4AMPkQwf8jl6szgvNd2tRIg==", + "dev": true, + "license": "MIT", + "dependencies": { + "pkg-dir": "^4.2.0", + "resolve-cwd": "^3.0.0" + }, + "bin": { + "import-local-fixture": "fixtures/cli.js" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/imurmurhash": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", + "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.8.19" + } + }, + "node_modules/inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==", + "dev": true, + "license": "ISC", + "dependencies": { + "once": "^1.3.0", + "wrappy": "1" + } + }, + "node_modules/inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", + "dev": true, + "license": "ISC" + }, + "node_modules/internal-slot": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.0.5.tgz", + "integrity": "sha512-Y+R5hJrzs52QCG2laLn4udYVnxsfny9CpOhNhUvk/SSSVyF6T27FzRbF0sroPidSu3X8oEAkOn2K804mjpt6UQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "get-intrinsic": "^1.2.0", + "has": "^1.0.3", + "side-channel": "^1.0.4" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/is-array-buffer": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/is-array-buffer/-/is-array-buffer-3.0.2.tgz", + "integrity": "sha512-y+FyyR/w8vfIRq4eQcM1EYgSTnmHXPqaF+IgzgraytCFq5Xh8lllDVmAZolPJiZttZLeFSINPYMaEJ7/vWUa1w==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.2", + "get-intrinsic": "^1.2.0", + "is-typed-array": "^1.1.10" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-arrayish": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz", + "integrity": "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==", + "dev": true, + "license": "MIT" + }, + "node_modules/is-bigint": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/is-bigint/-/is-bigint-1.0.4.tgz", + "integrity": "sha512-zB9CruMamjym81i2JZ3UMn54PKGsQzsJeo6xvN3HJJ4CAsQNB6iRutp2To77OfCNuoxspsIhzaPoO1zyCEhFOg==", + "dev": true, + "license": "MIT", + "dependencies": { + "has-bigints": "^1.0.1" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-boolean-object": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.1.2.tgz", + "integrity": "sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.2", + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-callable": { + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz", + "integrity": "sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-core-module": { + "version": "2.12.1", + "dev": true, + "license": "MIT", + "dependencies": { + "has": "^1.0.3" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-date-object": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.5.tgz", + "integrity": "sha512-9YQaSxsAiSwcvS33MBk3wTCVnWK+HhF8VZR2jRxehM16QcVOdHqPn4VPHmRK4lSr38n9JriurInLcP90xsYNfQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-extglob": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", + "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-fullwidth-code-point": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/is-generator-fn": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-generator-fn/-/is-generator-fn-2.1.0.tgz", + "integrity": "sha512-cTIB4yPYL/Grw0EaSzASzg6bBy9gqCofvWN8okThAYIxKJZC+udlRAmGbM0XLeniEJSs8uEgHPGuHSe1XsOLSQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/is-glob": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", + "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", + "license": "MIT", + "dependencies": { + "is-extglob": "^2.1.1" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-negative-zero": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/is-negative-zero/-/is-negative-zero-2.0.2.tgz", + "integrity": "sha512-dqJvarLawXsFbNDeJW7zAz8ItJ9cd28YufuuFzh0G8pNHjJMnY08Dv7sYX2uF5UpQOwieAeOExEYAWWfu7ZZUA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-number": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", + "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", + "license": "MIT", + "engines": { + "node": ">=0.12.0" + } + }, + "node_modules/is-number-object": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/is-number-object/-/is-number-object-1.0.7.tgz", + "integrity": "sha512-k1U0IRzLMo7ZlYIfzRu23Oh6MiIFasgpb9X76eqfFZAqwH44UI4KTBvBYIZ1dSL9ZzChTB9ShHfLkR4pdW5krQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-path-inside": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.3.tgz", + "integrity": "sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/is-regex": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.1.4.tgz", + "integrity": "sha512-kvRdxDsxZjhzUX07ZnLydzS1TU/TJlTUHHY4YLL87e37oUA49DfkLqgy+VjFocowy29cKvcSiu+kIv728jTTVg==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.2", + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-shared-array-buffer": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-shared-array-buffer/-/is-shared-array-buffer-1.0.2.tgz", + "integrity": "sha512-sqN2UDu1/0y6uvXyStCOzyhAjCSlHceFoMKJW8W9EU9cvic/QdsZ0kEU93HEy3IUEFZIiH/3w+AH/UQbPHNdhA==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.2" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-stream": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz", + "integrity": "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/is-string": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/is-string/-/is-string-1.0.7.tgz", + "integrity": "sha512-tE2UXzivje6ofPW7l23cjDOMa09gb7xlAqG6jG5ej6uPV32TlWP3NKPigtaGeHNu9fohccRYvIiZMfOOnOYUtg==", + "dev": true, + "license": "MIT", + "dependencies": { + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-symbol": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.4.tgz", + "integrity": "sha512-C/CPBqKWnvdcxqIARxyOh4v1UUEOCHpgDa0WYgpKDFMszcrPcffg5uhwSgPCLD2WWxmq6isisz87tzT01tuGhg==", + "dev": true, + "license": "MIT", + "dependencies": { + "has-symbols": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-typed-array": { + "version": "1.1.10", + "dev": true, + "license": "MIT", + "dependencies": { + "available-typed-arrays": "^1.0.5", + "call-bind": "^1.0.2", + "for-each": "^0.3.3", + "gopd": "^1.0.1", + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-weakref": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-weakref/-/is-weakref-1.0.2.tgz", + "integrity": "sha512-qctsuLZmIQ0+vSSMfoVvyFe2+GSEvnmZ2ezTup1SBse9+twCCeial6EEi3Nc2KFcf6+qz2FBPnjXsk8xhKSaPQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.2" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", + "dev": true, + "license": "ISC" + }, + "node_modules/istanbul-lib-coverage": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.0.tgz", + "integrity": "sha512-eOeJ5BHCmHYvQK7xt9GkdHuzuCGS1Y6g9Gvnx3Ym33fz/HpLRYxiS0wHNr+m/MBC8B647Xt608vCDEvhl9c6Mw==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=8" + } + }, + "node_modules/istanbul-lib-instrument": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/istanbul-lib-instrument/-/istanbul-lib-instrument-5.2.1.tgz", + "integrity": "sha512-pzqtp31nLv/XFOzXGuvhCb8qhjmTVo5vjVk19XE4CRlSWz0KoeJ3bw9XsA7nOp9YBf4qHjwBxkDzKcME/J29Yg==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "@babel/core": "^7.12.3", + "@babel/parser": "^7.14.7", + "@istanbuljs/schema": "^0.1.2", + "istanbul-lib-coverage": "^3.2.0", + "semver": "^6.3.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/istanbul-lib-report": { + "version": "3.0.0", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "istanbul-lib-coverage": "^3.0.0", + "make-dir": "^3.0.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/istanbul-lib-source-maps": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/istanbul-lib-source-maps/-/istanbul-lib-source-maps-4.0.1.tgz", + "integrity": "sha512-n3s8EwkdFIJCG3BPKBYvskgXGoy88ARzvegkitk60NxRdwltLOTaH7CUiMRXvwYorl0Q712iEjcWB+fK/MrWVw==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "debug": "^4.1.1", + "istanbul-lib-coverage": "^3.0.0", + "source-map": "^0.6.1" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/istanbul-reports": { + "version": "3.1.5", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "html-escaper": "^2.0.0", + "istanbul-lib-report": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/jest": { + "version": "29.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@jest/core": "^29.5.0", + "@jest/types": "^29.5.0", + "import-local": "^3.0.2", + "jest-cli": "^29.5.0" + }, + "bin": { + "jest": "bin/jest.js" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "peerDependencies": { + "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0" + }, + "peerDependenciesMeta": { + "node-notifier": { + "optional": true + } + } + }, + "node_modules/jest-changed-files": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-changed-files/-/jest-changed-files-29.5.0.tgz", + "integrity": "sha512-IFG34IUMUaNBIxjQXF/iu7g6EcdMrGRRxaUSw92I/2g2YC6vCdTltl4nHvt7Ci5nSJwXIkCu8Ka1DKF+X7Z1Ag==", + "dev": true, + "license": "MIT", + "dependencies": { + "execa": "^5.0.0", + "p-limit": "^3.1.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-circus": { + "version": "29.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@jest/environment": "^29.5.0", + "@jest/expect": "^29.5.0", + "@jest/test-result": "^29.5.0", + "@jest/types": "^29.5.0", + "@types/node": "*", + "chalk": "^4.0.0", + "co": "^4.6.0", + "dedent": "^0.7.0", + "is-generator-fn": "^2.0.0", + "jest-each": "^29.5.0", + "jest-matcher-utils": "^29.5.0", + "jest-message-util": "^29.5.0", + "jest-runtime": "^29.5.0", + "jest-snapshot": "^29.5.0", + "jest-util": "^29.5.0", + "p-limit": "^3.1.0", + "pretty-format": "^29.5.0", + "pure-rand": "^6.0.0", + "slash": "^3.0.0", + "stack-utils": "^2.0.3" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-cli": { + "version": "29.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@jest/core": "^29.5.0", + "@jest/test-result": "^29.5.0", + "@jest/types": "^29.5.0", + "chalk": "^4.0.0", + "exit": "^0.1.2", + "graceful-fs": "^4.2.9", + "import-local": "^3.0.2", + "jest-config": "^29.5.0", + "jest-util": "^29.5.0", + "jest-validate": "^29.5.0", + "prompts": "^2.0.1", + "yargs": "^17.3.1" + }, + "bin": { + "jest": "bin/jest.js" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "peerDependencies": { + "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0" + }, + "peerDependenciesMeta": { + "node-notifier": { + "optional": true + } + } + }, + "node_modules/jest-config": { + "version": "29.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/core": "^7.11.6", + "@jest/test-sequencer": "^29.5.0", + "@jest/types": "^29.5.0", + "babel-jest": "^29.5.0", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "deepmerge": "^4.2.2", + "glob": "^7.1.3", + "graceful-fs": "^4.2.9", + "jest-circus": "^29.5.0", + "jest-environment-node": "^29.5.0", + "jest-get-type": "^29.4.3", + "jest-regex-util": "^29.4.3", + "jest-resolve": "^29.5.0", + "jest-runner": "^29.5.0", + "jest-util": "^29.5.0", + "jest-validate": "^29.5.0", + "micromatch": "^4.0.4", + "parse-json": "^5.2.0", + "pretty-format": "^29.5.0", + "slash": "^3.0.0", + "strip-json-comments": "^3.1.1" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "peerDependencies": { + "@types/node": "*", + "ts-node": ">=9.0.0" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + }, + "ts-node": { + "optional": true + } + } + }, + "node_modules/jest-diff": { + "version": "29.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "chalk": "^4.0.0", + "diff-sequences": "^29.4.3", + "jest-get-type": "^29.4.3", + "pretty-format": "^29.5.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-docblock": { + "version": "29.4.3", + "resolved": "https://registry.npmjs.org/jest-docblock/-/jest-docblock-29.4.3.tgz", + "integrity": "sha512-fzdTftThczeSD9nZ3fzA/4KkHtnmllawWrXO69vtI+L9WjEIuXWs4AmyME7lN5hU7dB0sHhuPfcKofRsUb/2Fg==", + "dev": true, + "license": "MIT", + "dependencies": { + "detect-newline": "^3.0.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-each": { + "version": "29.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@jest/types": "^29.5.0", + "chalk": "^4.0.0", + "jest-get-type": "^29.4.3", + "jest-util": "^29.5.0", + "pretty-format": "^29.5.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-environment-node": { + "version": "29.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@jest/environment": "^29.5.0", + "@jest/fake-timers": "^29.5.0", + "@jest/types": "^29.5.0", + "@types/node": "*", + "jest-mock": "^29.5.0", + "jest-util": "^29.5.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-get-type": { + "version": "29.4.3", + "resolved": "https://registry.npmjs.org/jest-get-type/-/jest-get-type-29.4.3.tgz", + "integrity": "sha512-J5Xez4nRRMjk8emnTpWrlkyb9pfRQQanDrvWHhsR1+VUfbwxi30eVcZFlcdGInRibU4G5LwHXpI7IRHU0CY+gg==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-haste-map": { + "version": "29.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@jest/types": "^29.5.0", + "@types/graceful-fs": "^4.1.3", + "@types/node": "*", + "anymatch": "^3.0.3", + "fb-watchman": "^2.0.0", + "graceful-fs": "^4.2.9", + "jest-regex-util": "^29.4.3", + "jest-util": "^29.5.0", + "jest-worker": "^29.5.0", + "micromatch": "^4.0.4", + "walker": "^1.0.8" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "optionalDependencies": { + "fsevents": "^2.3.2" + } + }, + "node_modules/jest-leak-detector": { + "version": "29.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "jest-get-type": "^29.4.3", + "pretty-format": "^29.5.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-matcher-utils": { + "version": "29.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "chalk": "^4.0.0", + "jest-diff": "^29.5.0", + "jest-get-type": "^29.4.3", + "pretty-format": "^29.5.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-message-util": { + "version": "29.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.12.13", + "@jest/types": "^29.5.0", + "@types/stack-utils": "^2.0.0", + "chalk": "^4.0.0", + "graceful-fs": "^4.2.9", + "micromatch": "^4.0.4", + "pretty-format": "^29.5.0", + "slash": "^3.0.0", + "stack-utils": "^2.0.3" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-mock": { + "version": "29.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@jest/types": "^29.5.0", + "@types/node": "*", + "jest-util": "^29.5.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-pnp-resolver": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/jest-pnp-resolver/-/jest-pnp-resolver-1.2.3.tgz", + "integrity": "sha512-+3NpwQEnRoIBtx4fyhblQDPgJI0H1IEIkX7ShLUjPGA7TtUTvI1oiKi3SR4oBR0hQhQR80l4WAe5RrXBwWMA8w==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + }, + "peerDependencies": { + "jest-resolve": "*" + }, + "peerDependenciesMeta": { + "jest-resolve": { + "optional": true + } + } + }, + "node_modules/jest-regex-util": { + "version": "29.4.3", + "resolved": "https://registry.npmjs.org/jest-regex-util/-/jest-regex-util-29.4.3.tgz", + "integrity": "sha512-O4FglZaMmWXbGHSQInfXewIsd1LMn9p3ZXB/6r4FOkyhX2/iP/soMG98jGvk/A3HAN78+5VWcBGO0BJAPRh4kg==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-resolve": { + "version": "29.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "chalk": "^4.0.0", + "graceful-fs": "^4.2.9", + "jest-haste-map": "^29.5.0", + "jest-pnp-resolver": "^1.2.2", + "jest-util": "^29.5.0", + "jest-validate": "^29.5.0", + "resolve": "^1.20.0", + "resolve.exports": "^2.0.0", + "slash": "^3.0.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-resolve-dependencies": { + "version": "29.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "jest-regex-util": "^29.4.3", + "jest-snapshot": "^29.5.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-runner": { + "version": "29.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@jest/console": "^29.5.0", + "@jest/environment": "^29.5.0", + "@jest/test-result": "^29.5.0", + "@jest/transform": "^29.5.0", + "@jest/types": "^29.5.0", + "@types/node": "*", + "chalk": "^4.0.0", + "emittery": "^0.13.1", + "graceful-fs": "^4.2.9", + "jest-docblock": "^29.4.3", + "jest-environment-node": "^29.5.0", + "jest-haste-map": "^29.5.0", + "jest-leak-detector": "^29.5.0", + "jest-message-util": "^29.5.0", + "jest-resolve": "^29.5.0", + "jest-runtime": "^29.5.0", + "jest-util": "^29.5.0", + "jest-watcher": "^29.5.0", + "jest-worker": "^29.5.0", + "p-limit": "^3.1.0", + "source-map-support": "0.5.13" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-runtime": { + "version": "29.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@jest/environment": "^29.5.0", + "@jest/fake-timers": "^29.5.0", + "@jest/globals": "^29.5.0", + "@jest/source-map": "^29.4.3", + "@jest/test-result": "^29.5.0", + "@jest/transform": "^29.5.0", + "@jest/types": "^29.5.0", + "@types/node": "*", + "chalk": "^4.0.0", + "cjs-module-lexer": "^1.0.0", + "collect-v8-coverage": "^1.0.0", + "glob": "^7.1.3", + "graceful-fs": "^4.2.9", + "jest-haste-map": "^29.5.0", + "jest-message-util": "^29.5.0", + "jest-mock": "^29.5.0", + "jest-regex-util": "^29.4.3", + "jest-resolve": "^29.5.0", + "jest-snapshot": "^29.5.0", + "jest-util": "^29.5.0", + "slash": "^3.0.0", + "strip-bom": "^4.0.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-runtime/node_modules/strip-bom": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-4.0.0.tgz", + "integrity": "sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-snapshot": { + "version": "29.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/core": "^7.11.6", + "@babel/generator": "^7.7.2", + "@babel/plugin-syntax-jsx": "^7.7.2", + "@babel/plugin-syntax-typescript": "^7.7.2", + "@babel/traverse": "^7.7.2", + "@babel/types": "^7.3.3", + "@jest/expect-utils": "^29.5.0", + "@jest/transform": "^29.5.0", + "@jest/types": "^29.5.0", + "@types/babel__traverse": "^7.0.6", + "@types/prettier": "^2.1.5", + "babel-preset-current-node-syntax": "^1.0.0", + "chalk": "^4.0.0", + "expect": "^29.5.0", + "graceful-fs": "^4.2.9", + "jest-diff": "^29.5.0", + "jest-get-type": "^29.4.3", + "jest-matcher-utils": "^29.5.0", + "jest-message-util": "^29.5.0", + "jest-util": "^29.5.0", + "natural-compare": "^1.4.0", + "pretty-format": "^29.5.0", + "semver": "^7.3.5" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-snapshot/node_modules/semver": { + "version": "7.5.2", + "dev": true, + "license": "ISC", + "dependencies": { + "lru-cache": "^6.0.0" + }, + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/jest-util": { + "version": "29.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@jest/types": "^29.5.0", + "@types/node": "*", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "graceful-fs": "^4.2.9", + "picomatch": "^2.2.3" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-validate": { + "version": "29.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@jest/types": "^29.5.0", + "camelcase": "^6.2.0", + "chalk": "^4.0.0", + "jest-get-type": "^29.4.3", + "leven": "^3.1.0", + "pretty-format": "^29.5.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-watcher": { + "version": "29.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@jest/test-result": "^29.5.0", + "@jest/types": "^29.5.0", + "@types/node": "*", + "ansi-escapes": "^4.2.1", + "chalk": "^4.0.0", + "emittery": "^0.13.1", + "jest-util": "^29.5.0", + "string-length": "^4.0.1" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-worker": { + "version": "29.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/node": "*", + "jest-util": "^29.5.0", + "merge-stream": "^2.0.0", + "supports-color": "^8.0.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-worker/node_modules/supports-color": { + "version": "8.1.1", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz", + "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/supports-color?sponsor=1" + } + }, + "node_modules/js-sha256": { + "version": "0.9.0", + "resolved": "https://registry.npmjs.org/js-sha256/-/js-sha256-0.9.0.tgz", + "integrity": "sha512-sga3MHh9sgQN2+pJ9VYZ+1LPwXOxuBJBA5nrR5/ofPfuiJBE2hnjsaN8se8JznOmGLN2p49Pe5U/ttafcs/apA==", + "license": "MIT" + }, + "node_modules/js-sha3": { + "version": "0.8.0", + "resolved": "https://registry.npmjs.org/js-sha3/-/js-sha3-0.8.0.tgz", + "integrity": "sha512-gF1cRrHhIzNfToc802P800N8PpXS+evLLXfsVpowqmAFR9uwbi89WvXg2QspOmXL8QL86J4T1EpFu+yUkwJY3Q==", + "license": "MIT" + }, + "node_modules/js-sha512": { + "version": "0.8.0", + "resolved": "https://registry.npmjs.org/js-sha512/-/js-sha512-0.8.0.tgz", + "integrity": "sha512-PWsmefG6Jkodqt+ePTvBZCSMFgN7Clckjd0O7su3I0+BW2QWUTJNzjktHsztGLhncP2h8mcF9V9Y2Ha59pAViQ==", + "license": "MIT" + }, + "node_modules/js-tokens": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", + "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/js-yaml": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz", + "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==", + "dev": true, + "license": "MIT", + "dependencies": { + "argparse": "^2.0.1" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/jsesc": { + "version": "2.5.2", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-2.5.2.tgz", + "integrity": "sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==", + "dev": true, + "license": "MIT", + "bin": { + "jsesc": "bin/jsesc" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/json-bigint": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/json-bigint/-/json-bigint-1.0.0.tgz", + "integrity": "sha512-SiPv/8VpZuWbvLSMtTDU8hEfrZWg/mH/nV/b4o0CYbSxu1UIQPLdwKOCIyLQX+VIPO5vrLX3i8qtqFyhdPSUSQ==", + "license": "MIT", + "dependencies": { + "bignumber.js": "^9.0.0" + } + }, + "node_modules/json-parse-even-better-errors": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz", + "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==", + "dev": true, + "license": "MIT" + }, + "node_modules/json-schema-traverse": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", + "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==", + "dev": true, + "license": "MIT" + }, + "node_modules/json-stable-stringify-without-jsonify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz", + "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==", + "dev": true, + "license": "MIT" + }, + "node_modules/json5": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz", + "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==", + "dev": true, + "license": "MIT", + "bin": { + "json5": "lib/cli.js" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/jsonschema": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/jsonschema/-/jsonschema-1.4.1.tgz", + "integrity": "sha512-S6cATIPVv1z0IlxdN+zUk5EPjkGCdnhN4wVSBlvoUO1tOLJootbo9CquNJmbIh4yikWHiUedhRYrNPn1arpEmQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": "*" + } + }, + "node_modules/kleur": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/kleur/-/kleur-3.0.3.tgz", + "integrity": "sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/leven": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/leven/-/leven-3.1.0.tgz", + "integrity": "sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/levn": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz", + "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "prelude-ls": "^1.2.1", + "type-check": "~0.4.0" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/lines-and-columns": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz", + "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==", + "dev": true, + "license": "MIT" + }, + "node_modules/locate-path": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz", + "integrity": "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==", + "dev": true, + "license": "MIT", + "dependencies": { + "p-locate": "^4.1.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/lodash.memoize": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/lodash.memoize/-/lodash.memoize-4.1.2.tgz", + "integrity": "sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag==", + "dev": true, + "license": "MIT" + }, + "node_modules/lodash.merge": { + "version": "4.6.2", + "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz", + "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/lower-case": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/lower-case/-/lower-case-2.0.2.tgz", + "integrity": "sha512-7fm3l3NAF9WfN6W3JOmf5drwpVqX78JtoGJ3A6W0a6ZnldM41w2fV5D490psKFTpMds8TJse/eHLFFsNHHjHgg==", + "dev": true, + "license": "MIT", + "dependencies": { + "tslib": "^2.0.3" + } + }, + "node_modules/lru-cache": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz", + "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==", + "dev": true, + "license": "ISC", + "dependencies": { + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/make-dir": { + "version": "3.1.0", + "dev": true, + "license": "MIT", + "dependencies": { + "semver": "^6.0.0" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/make-error": { + "version": "1.3.6", + "resolved": "https://registry.npmjs.org/make-error/-/make-error-1.3.6.tgz", + "integrity": "sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==", + "dev": true, + "license": "ISC" + }, + "node_modules/makeerror": { + "version": "1.0.12", + "resolved": "https://registry.npmjs.org/makeerror/-/makeerror-1.0.12.tgz", + "integrity": "sha512-JmqCvUhmt43madlpFzG4BQzG2Z3m6tvQDNKdClZnO3VbIudJYmxsT0FNJMeiB2+JTSlTQTSbU8QdesVmwJcmLg==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "tmpl": "1.0.5" + } + }, + "node_modules/merge-stream": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz", + "integrity": "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==", + "dev": true, + "license": "MIT" + }, + "node_modules/merge2": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz", + "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==", + "license": "MIT", + "engines": { + "node": ">= 8" + } + }, + "node_modules/micromatch": { + "version": "4.0.5", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.5.tgz", + "integrity": "sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==", + "license": "MIT", + "dependencies": { + "braces": "^3.0.2", + "picomatch": "^2.3.1" + }, + "engines": { + "node": ">=8.6" + } + }, + "node_modules/mimic-fn": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz", + "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/minimatch": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", + "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "dev": true, + "license": "ISC", + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "node_modules/minimist": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz", + "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/mkdirp": { + "version": "2.1.6", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-2.1.6.tgz", + "integrity": "sha512-+hEnITedc8LAtIP9u3HJDFIdcLV2vXP33sqLLIzkv1Db1zO/1OxbvYf0Y1OC/S/Qo5dxHXepofhmxL02PsKe+A==", + "bin": { + "mkdirp": "dist/cjs/src/bin.js" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/ms": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", + "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==", + "dev": true, + "license": "MIT" + }, + "node_modules/natural-compare": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz", + "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==", + "dev": true, + "license": "MIT" + }, + "node_modules/natural-compare-lite": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/natural-compare-lite/-/natural-compare-lite-1.4.0.tgz", + "integrity": "sha512-Tj+HTDSJJKaZnfiuw+iaF9skdPpTo2GtEly5JHnWV/hfv2Qj/9RKsGISQtLh2ox3l5EAGw487hnBee0sIJ6v2g==", + "dev": true, + "license": "MIT" + }, + "node_modules/no-case": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/no-case/-/no-case-3.0.4.tgz", + "integrity": "sha512-fgAN3jGAh+RoxUGZHTSOLJIqUc2wmoBwGR4tbpNAKmmovFoWq0OdRkb0VkldReO2a2iBT/OEulG9XSUc10r3zg==", + "dev": true, + "license": "MIT", + "dependencies": { + "lower-case": "^2.0.2", + "tslib": "^2.0.3" + } + }, + "node_modules/node-fetch": { + "version": "2.7.0", + "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz", + "integrity": "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==", + "dependencies": { + "whatwg-url": "^5.0.0" + }, + "engines": { + "node": "4.x || >=6.0.0" + }, + "peerDependencies": { + "encoding": "^0.1.0" + }, + "peerDependenciesMeta": { + "encoding": { + "optional": true + } + } + }, + "node_modules/node-int64": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/node-int64/-/node-int64-0.4.0.tgz", + "integrity": "sha512-O5lz91xSOeoXP6DulyHfllpq+Eg00MWitZIbtPfoSEvqIHdl5gfcY6hYzDWnj0qD5tz52PI08u9qUvSVeUBeHw==", + "dev": true, + "license": "MIT" + }, + "node_modules/node-releases": { + "version": "2.0.12", + "dev": true, + "license": "MIT" + }, + "node_modules/normalize-path": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz", + "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/npm-run-path": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-4.0.1.tgz", + "integrity": "sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==", + "dev": true, + "license": "MIT", + "dependencies": { + "path-key": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/object-inspect": { + "version": "1.12.3", + "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.12.3.tgz", + "integrity": "sha512-geUvdk7c+eizMNUDkRpW1wJwgfOiOeHbxBR/hLXK1aT6zmVSO0jsQcs7fj6MGw89jC/cjGfLcNOrtMYtGqm81g==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/object-keys": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz", + "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/object.assign": { + "version": "4.1.4", + "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.4.tgz", + "integrity": "sha512-1mxKf0e58bvyjSCtKYY4sRe9itRk3PJpquJOjeIkz885CczcI4IvJJDLPS72oowuSh+pBxUFROpX+TU++hxhZQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "has-symbols": "^1.0.3", + "object-keys": "^1.1.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/object.entries": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/object.entries/-/object.entries-1.1.6.tgz", + "integrity": "sha512-leTPzo4Zvg3pmbQ3rDK69Rl8GQvIqMWubrkxONG9/ojtFE2rD9fjMKfSI5BxW3osRH1m6VdzmqK8oAY9aT4x5w==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/object.values": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/object.values/-/object.values-1.1.6.tgz", + "integrity": "sha512-FVVTkD1vENCsAcwNs9k6jea2uHC/X0+JcjG8YA60FN5CMaJmG95wT9jek/xX9nornqGRrBkKtzuAu2wuHpKqvw==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==", + "dev": true, + "license": "ISC", + "dependencies": { + "wrappy": "1" + } + }, + "node_modules/onetime": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz", + "integrity": "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==", + "dev": true, + "license": "MIT", + "dependencies": { + "mimic-fn": "^2.1.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/optionator": { + "version": "0.9.1", + "dev": true, + "license": "MIT", + "dependencies": { + "deep-is": "^0.1.3", + "fast-levenshtein": "^2.0.6", + "levn": "^0.4.1", + "prelude-ls": "^1.2.1", + "type-check": "^0.4.0", + "word-wrap": "^1.2.3" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/p-limit": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "yocto-queue": "^0.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/p-locate": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz", + "integrity": "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==", + "dev": true, + "license": "MIT", + "dependencies": { + "p-limit": "^2.2.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/p-locate/node_modules/p-limit": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz", + "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==", + "dev": true, + "license": "MIT", + "dependencies": { + "p-try": "^2.0.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/p-try": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz", + "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/param-case": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/param-case/-/param-case-3.0.4.tgz", + "integrity": "sha512-RXlj7zCYokReqWpOPH9oYivUzLYZ5vAPIfEmCTNViosC78F8F0H9y7T7gG2M39ymgutxF5gcFEsyZQSph9Bp3A==", + "dev": true, + "license": "MIT", + "dependencies": { + "dot-case": "^3.0.4", + "tslib": "^2.0.3" + } + }, + "node_modules/parent-module": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz", + "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==", + "dev": true, + "license": "MIT", + "dependencies": { + "callsites": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/parse-json": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-5.2.0.tgz", + "integrity": "sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.0.0", + "error-ex": "^1.3.1", + "json-parse-even-better-errors": "^2.3.0", + "lines-and-columns": "^1.1.6" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/pascal-case": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/pascal-case/-/pascal-case-3.1.2.tgz", + "integrity": "sha512-uWlGT3YSnK9x3BQJaOdcZwrnV6hPpd8jFH1/ucpiLRPh/2zCVJKS19E4GvYHvaCcACn3foXZ0cLB9Wrx1KGe5g==", + "dev": true, + "license": "MIT", + "dependencies": { + "no-case": "^3.0.4", + "tslib": "^2.0.3" + } + }, + "node_modules/path-browserify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-browserify/-/path-browserify-1.0.1.tgz", + "integrity": "sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g==" + }, + "node_modules/path-case": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/path-case/-/path-case-3.0.4.tgz", + "integrity": "sha512-qO4qCFjXqVTrcbPt/hQfhTQ+VhFsqNKOPtytgNKkKxSoEp3XPUQ8ObFuePylOIok5gjn69ry8XiULxCwot3Wfg==", + "dev": true, + "license": "MIT", + "dependencies": { + "dot-case": "^3.0.4", + "tslib": "^2.0.3" + } + }, + "node_modules/path-exists": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", + "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/path-is-absolute": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", + "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/path-key": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", + "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/path-parse": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", + "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", + "dev": true, + "license": "MIT" + }, + "node_modules/path-type": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz", + "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/picocolors": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.0.0.tgz", + "integrity": "sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==", + "dev": true, + "license": "ISC" + }, + "node_modules/picomatch": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", + "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", + "license": "MIT", + "engines": { + "node": ">=8.6" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/pirates": { + "version": "4.0.6", + "resolved": "https://registry.npmjs.org/pirates/-/pirates-4.0.6.tgz", + "integrity": "sha512-saLsH7WeYYPiD25LDuLRRY/i+6HaPYr6G1OUlN39otzkSTxKnubR9RTxS3/Kk50s1g2JTgFwWQDQyplC5/SHZg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 6" + } + }, + "node_modules/pkg-dir": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/pkg-dir/-/pkg-dir-4.2.0.tgz", + "integrity": "sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "find-up": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/prelude-ls": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz", + "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/pretty-format": { + "version": "29.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@jest/schemas": "^29.4.3", + "ansi-styles": "^5.0.0", + "react-is": "^18.0.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/pretty-format/node_modules/ansi-styles": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz", + "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/prompts": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/prompts/-/prompts-2.4.2.tgz", + "integrity": "sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "kleur": "^3.0.3", + "sisteransi": "^1.0.5" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/punycode": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.0.tgz", + "integrity": "sha512-rRV+zQD8tVFys26lAGR9WUuS4iUAngJScM+ZRSKtvl5tKeZ2t5bvdNFdNHBW9FWR4guGHlgmsZ1G7BSm2wTbuA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/pure-rand": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/pure-rand/-/pure-rand-6.0.2.tgz", + "integrity": "sha512-6Yg0ekpKICSjPswYOuC5sku/TSWaRYlA0qsXqJgM/d/4pLPHPuTxK7Nbf7jFKzAeedUhR8C7K9Uv63FBsSo8xQ==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://github.com/sponsors/dubzzz" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/fast-check" + } + ], + "license": "MIT" + }, + "node_modules/queue-microtask": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz", + "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT" + }, + "node_modules/react-is": { + "version": "18.2.0", + "resolved": "https://registry.npmjs.org/react-is/-/react-is-18.2.0.tgz", + "integrity": "sha512-xWGDIW6x921xtzPkhiULtthJHoJvBbF3q26fzloPCK0hsvxtPVelvftw3zjbHWSkR2km9Z+4uxbDDK/6Zw9B8w==", + "dev": true, + "license": "MIT" + }, + "node_modules/regexp.prototype.flags": { + "version": "1.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.2.0", + "functions-have-names": "^1.2.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/require-directory": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", + "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/resolve": { + "version": "1.22.2", + "dev": true, + "license": "MIT", + "dependencies": { + "is-core-module": "^2.11.0", + "path-parse": "^1.0.7", + "supports-preserve-symlinks-flag": "^1.0.0" + }, + "bin": { + "resolve": "bin/resolve" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/resolve-cwd": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/resolve-cwd/-/resolve-cwd-3.0.0.tgz", + "integrity": "sha512-OrZaX2Mb+rJCpH/6CpSqt9xFVpN++x01XnN2ie9g6P5/3xelLAkXWVADpdz1IHD/KFfEXyE6V0U01OQ3UO2rEg==", + "dev": true, + "license": "MIT", + "dependencies": { + "resolve-from": "^5.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/resolve-from": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz", + "integrity": "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/resolve.exports": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/resolve.exports/-/resolve.exports-2.0.2.tgz", + "integrity": "sha512-X2UW6Nw3n/aMgDVy+0rSqgHlv39WZAlZrXCdnbyEiKm17DSqHX4MmQMaST3FbeWR5FTuRcUwYAziZajji0Y7mg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + } + }, + "node_modules/reusify": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz", + "integrity": "sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==", + "license": "MIT", + "engines": { + "iojs": ">=1.0.0", + "node": ">=0.10.0" + } + }, + "node_modules/rimraf": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz", + "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==", + "dev": true, + "license": "ISC", + "dependencies": { + "glob": "^7.1.3" + }, + "bin": { + "rimraf": "bin.js" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/run-parallel": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz", + "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT", + "dependencies": { + "queue-microtask": "^1.2.2" + } + }, + "node_modules/safe-regex-test": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/safe-regex-test/-/safe-regex-test-1.0.0.tgz", + "integrity": "sha512-JBUUzyOgEwXQY1NuPtvcj/qcBDbDmEvWufhlnXZIm75DEHp+afM1r1ujJpJsV/gSM4t59tpDyPi1sd6ZaPFfsA==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.2", + "get-intrinsic": "^1.1.3", + "is-regex": "^1.1.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/semver": { + "version": "6.3.0", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/sentence-case": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/sentence-case/-/sentence-case-3.0.4.tgz", + "integrity": "sha512-8LS0JInaQMCRoQ7YUytAo/xUu5W2XnQxV2HI/6uM6U7CITS1RqPElr30V6uIqyMKM9lJGRVFy5/4CuzcixNYSg==", + "dev": true, + "license": "MIT", + "dependencies": { + "no-case": "^3.0.4", + "tslib": "^2.0.3", + "upper-case-first": "^2.0.2" + } + }, + "node_modules/shebang-command": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", + "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", + "dev": true, + "license": "MIT", + "dependencies": { + "shebang-regex": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/shebang-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", + "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/side-channel": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.4.tgz", + "integrity": "sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.0", + "get-intrinsic": "^1.0.2", + "object-inspect": "^1.9.0" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/signal-exit": { + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz", + "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==", + "dev": true, + "license": "ISC" + }, + "node_modules/sisteransi": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/sisteransi/-/sisteransi-1.0.5.tgz", + "integrity": "sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==", + "dev": true, + "license": "MIT" + }, + "node_modules/slash": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz", + "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/snake-case": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/snake-case/-/snake-case-3.0.4.tgz", + "integrity": "sha512-LAOh4z89bGQvl9pFfNF8V146i7o7/CqFPbqzYgP+yYzDIDeS9HaNFtXABamRW+AQzEVODcvE79ljJ+8a9YSdMg==", + "dev": true, + "license": "MIT", + "dependencies": { + "dot-case": "^3.0.4", + "tslib": "^2.0.3" + } + }, + "node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/source-map-support": { + "version": "0.5.13", + "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.13.tgz", + "integrity": "sha512-SHSKFHadjVA5oR4PPqhtAVdcBWwRYVd6g6cAXnIbRiIwc2EhPrTuKUBdSLvlEKyIP3GCf89fltvcZiP9MMFA1w==", + "dev": true, + "license": "MIT", + "dependencies": { + "buffer-from": "^1.0.0", + "source-map": "^0.6.0" + } + }, + "node_modules/sprintf-js": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz", + "integrity": "sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==", + "dev": true, + "license": "BSD-3-Clause" + }, + "node_modules/stack-utils": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/stack-utils/-/stack-utils-2.0.6.tgz", + "integrity": "sha512-XlkWvfIm6RmsWtNJx+uqtKLS8eqFbxUg0ZzLXqY0caEy9l7hruX8IpiDnjsLavoBgqCCR71TqWO8MaXYheJ3RQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "escape-string-regexp": "^2.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/stack-utils/node_modules/escape-string-regexp": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-2.0.0.tgz", + "integrity": "sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/string-length": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/string-length/-/string-length-4.0.2.tgz", + "integrity": "sha512-+l6rNN5fYHNhZZy41RXsYptCjA2Igmq4EG7kZAYFQI1E1VTXarr6ZPXBg6eq7Y6eK4FEhY6AJlyuFIb/v/S0VQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "char-regex": "^1.0.2", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/string-width": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "dev": true, + "license": "MIT", + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/string.prototype.trim": { + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.2.7.tgz", + "integrity": "sha512-p6TmeT1T3411M8Cgg9wBTMRtY2q9+PNy9EV1i2lIXUN/btt763oIfxwN3RR8VU6wHX8j/1CFy0L+YuThm6bgOg==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/string.prototype.trimend": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.6.tgz", + "integrity": "sha512-JySq+4mrPf9EsDBEDYMOb/lM7XQLulwg5R/m1r0PXEFqrV0qHvl58sdTilSXtKOflCsK2E8jxf+GKC0T07RWwQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/string.prototype.trimstart": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.6.tgz", + "integrity": "sha512-omqjMDaY92pbn5HOX7f9IccLA+U1tA9GvtU4JrodiXFfYB7jPzzHpRzpglLAjtUV6bB557zwClJezTqnAiYnQA==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-bom": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", + "integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/strip-final-newline": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-2.0.0.tgz", + "integrity": "sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/strip-json-comments": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz", + "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dev": true, + "license": "MIT", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/supports-preserve-symlinks-flag": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz", + "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/test-exclude": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/test-exclude/-/test-exclude-6.0.0.tgz", + "integrity": "sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==", + "dev": true, + "license": "ISC", + "dependencies": { + "@istanbuljs/schema": "^0.1.2", + "glob": "^7.1.4", + "minimatch": "^3.0.4" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/text-table": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz", + "integrity": "sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==", + "dev": true, + "license": "MIT" + }, + "node_modules/tmpl": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/tmpl/-/tmpl-1.0.5.tgz", + "integrity": "sha512-3f0uOEAQwIqGuWW2MVzYg8fV/QNnc/IpuJNG837rLuczAaLVHslWHZQj4IGiEl5Hs3kkbhwL9Ab7Hrsmuj+Smw==", + "dev": true, + "license": "BSD-3-Clause" + }, + "node_modules/to-fast-properties": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-2.0.0.tgz", + "integrity": "sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/to-regex-range": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", + "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", + "license": "MIT", + "dependencies": { + "is-number": "^7.0.0" + }, + "engines": { + "node": ">=8.0" + } + }, + "node_modules/tr46": { + "version": "0.0.3", + "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz", + "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==", + "license": "MIT" + }, + "node_modules/ts-jest": { + "version": "29.1.0", + "dev": true, + "license": "MIT", + "dependencies": { + "bs-logger": "0.x", + "fast-json-stable-stringify": "2.x", + "jest-util": "^29.0.0", + "json5": "^2.2.3", + "lodash.memoize": "4.x", + "make-error": "1.x", + "semver": "7.x", + "yargs-parser": "^21.0.1" + }, + "bin": { + "ts-jest": "cli.js" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "peerDependencies": { + "@babel/core": ">=7.0.0-beta.0 <8", + "@jest/types": "^29.0.0", + "babel-jest": "^29.0.0", + "jest": "^29.0.0", + "typescript": ">=4.3 <6" + }, + "peerDependenciesMeta": { + "@babel/core": { + "optional": true + }, + "@jest/types": { + "optional": true + }, + "babel-jest": { + "optional": true + }, + "esbuild": { + "optional": true + } + } + }, + "node_modules/ts-jest/node_modules/semver": { + "version": "7.5.2", + "dev": true, + "license": "ISC", + "dependencies": { + "lru-cache": "^6.0.0" + }, + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/ts-morph": { + "version": "20.0.0", + "resolved": "https://registry.npmjs.org/ts-morph/-/ts-morph-20.0.0.tgz", + "integrity": "sha512-JVmEJy2Wow5n/84I3igthL9sudQ8qzjh/6i4tmYCm6IqYyKFlNbJZi7oBdjyqcWSWYRu3CtL0xbT6fS03ESZIg==", + "dependencies": { + "@ts-morph/common": "~0.21.0", + "code-block-writer": "^12.0.0" + } + }, + "node_modules/tsconfig-paths": { + "version": "3.14.2", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/json5": "^0.0.29", + "json5": "^1.0.2", + "minimist": "^1.2.6", + "strip-bom": "^3.0.0" + } + }, + "node_modules/tsconfig-paths/node_modules/json5": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/json5/-/json5-1.0.2.tgz", + "integrity": "sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA==", + "dev": true, + "license": "MIT", + "dependencies": { + "minimist": "^1.2.0" + }, + "bin": { + "json5": "lib/cli.js" + } + }, + "node_modules/tslib": { + "version": "2.5.3", + "dev": true, + "license": "0BSD" + }, + "node_modules/tsutils": { + "version": "3.21.0", + "resolved": "https://registry.npmjs.org/tsutils/-/tsutils-3.21.0.tgz", + "integrity": "sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA==", + "dev": true, + "license": "MIT", + "dependencies": { + "tslib": "^1.8.1" + }, + "engines": { + "node": ">= 6" + }, + "peerDependencies": { + "typescript": ">=2.8.0 || >= 3.2.0-dev || >= 3.3.0-dev || >= 3.4.0-dev || >= 3.5.0-dev || >= 3.6.0-dev || >= 3.6.0-beta || >= 3.7.0-dev || >= 3.7.0-beta" + } + }, + "node_modules/tsutils/node_modules/tslib": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz", + "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==", + "dev": true, + "license": "0BSD" + }, + "node_modules/tweetnacl": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/tweetnacl/-/tweetnacl-1.0.3.tgz", + "integrity": "sha512-6rt+RN7aOi1nGMyC4Xa5DdYiukl2UWCbcJft7YhxReBGQD7OAM8Pbxw6YMo4r2diNEA8FEmu32YOn9rhaiE5yw==", + "license": "Unlicense" + }, + "node_modules/type-check": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz", + "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==", + "dev": true, + "license": "MIT", + "dependencies": { + "prelude-ls": "^1.2.1" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/type-detect": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/type-detect/-/type-detect-4.0.8.tgz", + "integrity": "sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/type-fest": { + "version": "0.20.2", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz", + "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==", + "dev": true, + "license": "(MIT OR CC0-1.0)", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/typed-array-length": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/typed-array-length/-/typed-array-length-1.0.4.tgz", + "integrity": "sha512-KjZypGq+I/H7HI5HlOoGHkWUUGq+Q0TPhQurLbyrVrvnKTBgzLhIJ7j6J/XTQOi0d1RjyZ0wdas8bKs2p0x3Ng==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.2", + "for-each": "^0.3.3", + "is-typed-array": "^1.1.9" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/typescript": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.0.2.tgz", + "integrity": "sha512-wVORMBGO/FAs/++blGNeAVdbNKtIh1rbBL2EyQ1+J9lClJ93KiiKe8PmFIVdXhHcyv44SL9oglmfeSsndo0jRw==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=12.20" + } + }, + "node_modules/unbox-primitive": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.0.2.tgz", + "integrity": "sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.2", + "has-bigints": "^1.0.2", + "has-symbols": "^1.0.3", + "which-boxed-primitive": "^1.0.2" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/update-browserslist-db": { + "version": "1.0.11", + "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.0.11.tgz", + "integrity": "sha512-dCwEFf0/oT85M1fHBg4F0jtLwJrutGoHSQXCh7u4o2t1drG+c0a9Flnqww6XUKSfQMPpJBRjU8d4RXB09qtvaA==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "escalade": "^3.1.1", + "picocolors": "^1.0.0" + }, + "bin": { + "update-browserslist-db": "cli.js" + }, + "peerDependencies": { + "browserslist": ">= 4.21.0" + } + }, + "node_modules/upper-case": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/upper-case/-/upper-case-2.0.2.tgz", + "integrity": "sha512-KgdgDGJt2TpuwBUIjgG6lzw2GWFRCW9Qkfkiv0DxqHHLYJHmtmdUIKcZd8rHgFSjopVTlw6ggzCm1b8MFQwikg==", + "dev": true, + "license": "MIT", + "dependencies": { + "tslib": "^2.0.3" + } + }, + "node_modules/upper-case-first": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/upper-case-first/-/upper-case-first-2.0.2.tgz", + "integrity": "sha512-514ppYHBaKwfJRK/pNC6c/OxfGa0obSnAl106u97Ed0I625Nin96KAjttZF6ZL3e1XLtphxnqrOi9iWgm+u+bg==", + "dev": true, + "license": "MIT", + "dependencies": { + "tslib": "^2.0.3" + } + }, + "node_modules/uri-js": { + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz", + "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "punycode": "^2.1.0" + } + }, + "node_modules/v8-to-istanbul": { + "version": "9.1.0", + "resolved": "https://registry.npmjs.org/v8-to-istanbul/-/v8-to-istanbul-9.1.0.tgz", + "integrity": "sha512-6z3GW9x8G1gd+JIIgQQQxXuiJtCXeAjp6RaPEPLv62mH3iPHPxV6W3robxtCzNErRo6ZwTmzWhsbNvjyEBKzKA==", + "dev": true, + "license": "ISC", + "dependencies": { + "@jridgewell/trace-mapping": "^0.3.12", + "@types/istanbul-lib-coverage": "^2.0.1", + "convert-source-map": "^1.6.0" + }, + "engines": { + "node": ">=10.12.0" + } + }, + "node_modules/vlq": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/vlq/-/vlq-2.0.4.tgz", + "integrity": "sha512-aodjPa2wPQFkra1G8CzJBTHXhgk3EVSwxSWXNPr1fgdFLUb8kvLV1iEb6rFgasIsjP82HWI6dsb5Io26DDnasA==", + "license": "MIT" + }, + "node_modules/walker": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/walker/-/walker-1.0.8.tgz", + "integrity": "sha512-ts/8E8l5b7kY0vlWLewOkDXMmPdLcVV4GmOQLyxuSswIJsweeFZtAsMF7k1Nszz+TYBQrlYRmzOnr398y1JemQ==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "makeerror": "1.0.12" + } + }, + "node_modules/webidl-conversions": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz", + "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==", + "license": "BSD-2-Clause" + }, + "node_modules/whatwg-url": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz", + "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==", + "license": "MIT", + "dependencies": { + "tr46": "~0.0.3", + "webidl-conversions": "^3.0.0" + } + }, + "node_modules/which": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "dev": true, + "license": "ISC", + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "node-which": "bin/node-which" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/which-boxed-primitive": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/which-boxed-primitive/-/which-boxed-primitive-1.0.2.tgz", + "integrity": "sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-bigint": "^1.0.1", + "is-boolean-object": "^1.1.0", + "is-number-object": "^1.0.4", + "is-string": "^1.0.5", + "is-symbol": "^1.0.3" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/which-typed-array": { + "version": "1.1.9", + "dev": true, + "license": "MIT", + "dependencies": { + "available-typed-arrays": "^1.0.5", + "call-bind": "^1.0.2", + "for-each": "^0.3.3", + "gopd": "^1.0.1", + "has-tostringtag": "^1.0.0", + "is-typed-array": "^1.1.10" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/word-wrap": { + "version": "1.2.3", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/wrap-ansi": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", + "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, + "node_modules/wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==", + "dev": true, + "license": "ISC" + }, + "node_modules/write-file-atomic": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-4.0.2.tgz", + "integrity": "sha512-7KxauUdBmSdWnmpaGFg+ppNjKF8uNLry8LyzjauQDOVONfFLNKrKvQOxZ/VuTIcS/gge/YNahf5RIIQWTSarlg==", + "dev": true, + "license": "ISC", + "dependencies": { + "imurmurhash": "^0.1.4", + "signal-exit": "^3.0.7" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || >=16.0.0" + } + }, + "node_modules/y18n": { + "version": "5.0.8", + "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz", + "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=10" + } + }, + "node_modules/yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==", + "dev": true, + "license": "ISC" + }, + "node_modules/yargs": { + "version": "17.7.2", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz", + "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==", + "dev": true, + "license": "MIT", + "dependencies": { + "cliui": "^8.0.1", + "escalade": "^3.1.1", + "get-caller-file": "^2.0.5", + "require-directory": "^2.1.1", + "string-width": "^4.2.3", + "y18n": "^5.0.5", + "yargs-parser": "^21.1.1" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/yargs-parser": { + "version": "21.1.1", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz", + "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/yocto-queue": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", + "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + } + }, + "dependencies": { + "@algorandfoundation/algokit-client-generator": { + "version": "2.2.1", + "dev": true, + "requires": { + "@algorandfoundation/algokit-utils": "^2.1.0", + "chalk": "^4.1.2", + "change-case": "^4.1.2", + "commander": "^10.0.1", + "jsonschema": "^1.4.1" + }, + "dependencies": { + "@algorandfoundation/algokit-utils": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/@algorandfoundation/algokit-utils/-/algokit-utils-2.3.2.tgz", + "integrity": "sha512-+Q4b8OVXogjkthapH04k+AqY19hxklfXFTmvoaQdQbbo2rUk1AgSXBRq0ThVg7n7RhfSMMUh0ZIL5bpse7MSKA==", + "dev": true, + "requires": { + "algosdk": "^2.3.0", + "buffer": "^6.0.3" + } + } + } + }, + "@algorandfoundation/algokit-utils": { + "version": "5.1.3", + "resolved": "https://registry.npmjs.org/@algorandfoundation/algokit-utils/-/algokit-utils-5.1.3.tgz", + "integrity": "sha512-TYkJioqOSG4DhW8phAdMhGi5QUla64PRzoi+5Ixq4LA371xZ2zegQFvHjoXZXMIIJaD8HckihlDju7K7U3xj8Q==", + "requires": { + "buffer": "^6.0.3" + } + }, + "@algorandfoundation/tealscript": { + "version": "0.51.1", + "resolved": "https://registry.npmjs.org/@algorandfoundation/tealscript/-/tealscript-0.51.1.tgz", + "integrity": "sha512-VM1orcyoy1VqzwD2jKNxbef6elq94KneH5SuXYM8FdBsFEqD7STukIWGWBQ/5om/LbtomvhwHx7GrWx6m+HjWA==", + "requires": { + "@microsoft/tsdoc": "^0.14.2", + "argparse": "^2.0.1", + "dotenv": "^16.3.1", + "node-fetch": "2", + "source-map": "^0.7.4", + "ts-morph": "^20.0.0", + "typescript": "^4.9.3", + "vlq": "^2.0.4" + }, + "dependencies": { + "source-map": { + "version": "0.7.4", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.7.4.tgz", + "integrity": "sha512-l3BikUxvPOcn5E74dZiq5BGsTb5yEwhaTSzccU6t4sDOH8NWJCstKO5QT2CvtFoK6F0saL7p9xHAqHOlCPJygA==" + }, + "typescript": { + "version": "4.9.5", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.9.5.tgz", + "integrity": "sha512-1FXk9E2Hm+QzZQ7z+McJiHL4NW1F2EzMu9Nq9i3zAaGqibafqYwCVU6WyWAuyQRRzOlxou8xZSyXLEN8oKj24g==" + } + } + }, + "@ampproject/remapping": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/@ampproject/remapping/-/remapping-2.2.1.tgz", + "integrity": "sha512-lFMjJTrFL3j7L9yBxwYfCq2k6qqwHyzuUl/XBnif78PWTJYyL/dfowQHWE3sp6U6ZzqWiiIZnpTMO96zhkjwtg==", + "dev": true, + "requires": { + "@jridgewell/gen-mapping": "^0.3.0", + "@jridgewell/trace-mapping": "^0.3.9" + } + }, + "@babel/code-frame": { + "version": "7.22.5", + "dev": true, + "requires": { + "@babel/highlight": "^7.22.5" + } + }, + "@babel/compat-data": { + "version": "7.22.5", + "dev": true + }, + "@babel/core": { + "version": "7.22.5", + "dev": true, + "requires": { + "@ampproject/remapping": "^2.2.0", + "@babel/code-frame": "^7.22.5", + "@babel/generator": "^7.22.5", + "@babel/helper-compilation-targets": "^7.22.5", + "@babel/helper-module-transforms": "^7.22.5", + "@babel/helpers": "^7.22.5", + "@babel/parser": "^7.22.5", + "@babel/template": "^7.22.5", + "@babel/traverse": "^7.22.5", + "@babel/types": "^7.22.5", + "convert-source-map": "^1.7.0", + "debug": "^4.1.0", + "gensync": "^1.0.0-beta.2", + "json5": "^2.2.2", + "semver": "^6.3.0" + } + }, + "@babel/generator": { + "version": "7.22.5", + "dev": true, + "requires": { + "@babel/types": "^7.22.5", + "@jridgewell/gen-mapping": "^0.3.2", + "@jridgewell/trace-mapping": "^0.3.17", + "jsesc": "^2.5.1" + } + }, + "@babel/helper-compilation-targets": { + "version": "7.22.5", + "dev": true, + "requires": { + "@babel/compat-data": "^7.22.5", + "@babel/helper-validator-option": "^7.22.5", + "browserslist": "^4.21.3", + "lru-cache": "^5.1.1", + "semver": "^6.3.0" + }, + "dependencies": { + "lru-cache": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz", + "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==", + "dev": true, + "requires": { + "yallist": "^3.0.2" + } + }, + "yallist": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz", + "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==", + "dev": true + } + } + }, + "@babel/helper-environment-visitor": { + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-environment-visitor/-/helper-environment-visitor-7.22.5.tgz", + "integrity": "sha512-XGmhECfVA/5sAt+H+xpSg0mfrHq6FzNr9Oxh7PSEBBRUb/mL7Kz3NICXb194rCqAEdxkhPT1a88teizAFyvk8Q==", + "dev": true + }, + "@babel/helper-function-name": { + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.22.5.tgz", + "integrity": "sha512-wtHSq6jMRE3uF2otvfuD3DIvVhOsSNshQl0Qrd7qC9oQJzHvOL4qQXlQn2916+CXGywIjpGuIkoyZRRxHPiNQQ==", + "dev": true, + "requires": { + "@babel/template": "^7.22.5", + "@babel/types": "^7.22.5" + } + }, + "@babel/helper-hoist-variables": { + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-hoist-variables/-/helper-hoist-variables-7.22.5.tgz", + "integrity": "sha512-wGjk9QZVzvknA6yKIUURb8zY3grXCcOZt+/7Wcy8O2uctxhplmUPkOdlgoNhmdVee2c92JXbf1xpMtVNbfoxRw==", + "dev": true, + "requires": { + "@babel/types": "^7.22.5" + } + }, + "@babel/helper-module-imports": { + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.22.5.tgz", + "integrity": "sha512-8Dl6+HD/cKifutF5qGd/8ZJi84QeAKh+CEe1sBzz8UayBBGg1dAIJrdHOcOM5b2MpzWL2yuotJTtGjETq0qjXg==", + "dev": true, + "requires": { + "@babel/types": "^7.22.5" + } + }, + "@babel/helper-module-transforms": { + "version": "7.22.5", + "dev": true, + "requires": { + "@babel/helper-environment-visitor": "^7.22.5", + "@babel/helper-module-imports": "^7.22.5", + "@babel/helper-simple-access": "^7.22.5", + "@babel/helper-split-export-declaration": "^7.22.5", + "@babel/helper-validator-identifier": "^7.22.5", + "@babel/template": "^7.22.5", + "@babel/traverse": "^7.22.5", + "@babel/types": "^7.22.5" + } + }, + "@babel/helper-plugin-utils": { + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.22.5.tgz", + "integrity": "sha512-uLls06UVKgFG9QD4OeFYLEGteMIAa5kpTPcFL28yuCIIzsf6ZyKZMllKVOCZFhiZ5ptnwX4mtKdWCBE/uT4amg==", + "dev": true + }, + "@babel/helper-simple-access": { + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-simple-access/-/helper-simple-access-7.22.5.tgz", + "integrity": "sha512-n0H99E/K+Bika3++WNL17POvo4rKWZ7lZEp1Q+fStVbUi8nxPQEBOlTmCOxW/0JsS56SKKQ+ojAe2pHKJHN35w==", + "dev": true, + "requires": { + "@babel/types": "^7.22.5" + } + }, + "@babel/helper-split-export-declaration": { + "version": "7.22.5", + "dev": true, + "requires": { + "@babel/types": "^7.22.5" + } + }, + "@babel/helper-string-parser": { + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.22.5.tgz", + "integrity": "sha512-mM4COjgZox8U+JcXQwPijIZLElkgEpO5rsERVDJTc2qfCDfERyob6k5WegS14SX18IIjv+XD+GrqNumY5JRCDw==", + "dev": true + }, + "@babel/helper-validator-identifier": { + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.22.5.tgz", + "integrity": "sha512-aJXu+6lErq8ltp+JhkJUfk1MTGyuA4v7f3pA+BJ5HLfNC6nAQ0Cpi9uOquUj8Hehg0aUiHzWQbOVJGao6ztBAQ==", + "dev": true + }, + "@babel/helper-validator-option": { + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.22.5.tgz", + "integrity": "sha512-R3oB6xlIVKUnxNUxbmgq7pKjxpru24zlimpE8WK47fACIlM0II/Hm1RS8IaOI7NgCr6LNS+jl5l75m20npAziw==", + "dev": true + }, + "@babel/helpers": { + "version": "7.22.5", + "dev": true, + "requires": { + "@babel/template": "^7.22.5", + "@babel/traverse": "^7.22.5", + "@babel/types": "^7.22.5" + } + }, + "@babel/highlight": { + "version": "7.22.5", + "dev": true, + "requires": { + "@babel/helper-validator-identifier": "^7.22.5", + "chalk": "^2.0.0", + "js-tokens": "^4.0.0" + }, + "dependencies": { + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dev": true, + "requires": { + "color-convert": "^1.9.0" + } + }, + "chalk": { + "version": "2.4.2", + "dev": true, + "requires": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + } + }, + "color-convert": { + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz", + "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==", + "dev": true, + "requires": { + "color-name": "1.1.3" + } + }, + "color-name": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", + "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==", + "dev": true + }, + "escape-string-regexp": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", + "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==", + "dev": true + }, + "has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==", + "dev": true + }, + "supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "dev": true, + "requires": { + "has-flag": "^3.0.0" + } + } + } + }, + "@babel/parser": { + "version": "7.22.5", + "dev": true + }, + "@babel/plugin-syntax-async-generators": { + "version": "7.8.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-async-generators/-/plugin-syntax-async-generators-7.8.4.tgz", + "integrity": "sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.8.0" + } + }, + "@babel/plugin-syntax-bigint": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-bigint/-/plugin-syntax-bigint-7.8.3.tgz", + "integrity": "sha512-wnTnFlG+YxQm3vDxpGE57Pj0srRU4sHE/mDkt1qv2YJJSeUAec2ma4WLUnUPeKjyrfntVwe/N6dCXpU+zL3Npg==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.8.0" + } + }, + "@babel/plugin-syntax-class-properties": { + "version": "7.12.13", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-class-properties/-/plugin-syntax-class-properties-7.12.13.tgz", + "integrity": "sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.12.13" + } + }, + "@babel/plugin-syntax-import-meta": { + "version": "7.10.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-meta/-/plugin-syntax-import-meta-7.10.4.tgz", + "integrity": "sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.10.4" + } + }, + "@babel/plugin-syntax-json-strings": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-json-strings/-/plugin-syntax-json-strings-7.8.3.tgz", + "integrity": "sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.8.0" + } + }, + "@babel/plugin-syntax-jsx": { + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.22.5.tgz", + "integrity": "sha512-gvyP4hZrgrs/wWMaocvxZ44Hw0b3W8Pe+cMxc8V1ULQ07oh8VNbIRaoD1LRZVTvD+0nieDKjfgKg89sD7rrKrg==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.22.5" + } + }, + "@babel/plugin-syntax-logical-assignment-operators": { + "version": "7.10.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-logical-assignment-operators/-/plugin-syntax-logical-assignment-operators-7.10.4.tgz", + "integrity": "sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.10.4" + } + }, + "@babel/plugin-syntax-nullish-coalescing-operator": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-nullish-coalescing-operator/-/plugin-syntax-nullish-coalescing-operator-7.8.3.tgz", + "integrity": "sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.8.0" + } + }, + "@babel/plugin-syntax-numeric-separator": { + "version": "7.10.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-numeric-separator/-/plugin-syntax-numeric-separator-7.10.4.tgz", + "integrity": "sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.10.4" + } + }, + "@babel/plugin-syntax-object-rest-spread": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-object-rest-spread/-/plugin-syntax-object-rest-spread-7.8.3.tgz", + "integrity": "sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.8.0" + } + }, + "@babel/plugin-syntax-optional-catch-binding": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-optional-catch-binding/-/plugin-syntax-optional-catch-binding-7.8.3.tgz", + "integrity": "sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.8.0" + } + }, + "@babel/plugin-syntax-optional-chaining": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-optional-chaining/-/plugin-syntax-optional-chaining-7.8.3.tgz", + "integrity": "sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.8.0" + } + }, + "@babel/plugin-syntax-top-level-await": { + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-top-level-await/-/plugin-syntax-top-level-await-7.14.5.tgz", + "integrity": "sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.14.5" + } + }, + "@babel/plugin-syntax-typescript": { + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.22.5.tgz", + "integrity": "sha512-1mS2o03i7t1c6VzH6fdQ3OA8tcEIxwG18zIPRp+UY1Ihv6W+XZzBCVxExF9upussPXJ0xE9XRHwMoNs1ep/nRQ==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.22.5" + } + }, + "@babel/template": { + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.22.5.tgz", + "integrity": "sha512-X7yV7eiwAxdj9k94NEylvbVHLiVG1nvzCV2EAowhxLTwODV1jl9UzZ48leOC0sH7OnuHrIkllaBgneUykIcZaw==", + "dev": true, + "requires": { + "@babel/code-frame": "^7.22.5", + "@babel/parser": "^7.22.5", + "@babel/types": "^7.22.5" + } + }, + "@babel/traverse": { + "version": "7.22.5", + "dev": true, + "requires": { + "@babel/code-frame": "^7.22.5", + "@babel/generator": "^7.22.5", + "@babel/helper-environment-visitor": "^7.22.5", + "@babel/helper-function-name": "^7.22.5", + "@babel/helper-hoist-variables": "^7.22.5", + "@babel/helper-split-export-declaration": "^7.22.5", + "@babel/parser": "^7.22.5", + "@babel/types": "^7.22.5", + "debug": "^4.1.0", + "globals": "^11.1.0" + }, + "dependencies": { + "globals": { + "version": "11.12.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz", + "integrity": "sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==", + "dev": true + } + } + }, + "@babel/types": { + "version": "7.22.5", + "dev": true, + "requires": { + "@babel/helper-string-parser": "^7.22.5", + "@babel/helper-validator-identifier": "^7.22.5", + "to-fast-properties": "^2.0.0" + } + }, + "@bcoe/v8-coverage": { + "version": "0.2.3", + "resolved": "https://registry.npmjs.org/@bcoe/v8-coverage/-/v8-coverage-0.2.3.tgz", + "integrity": "sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==", + "dev": true + }, + "@eslint-community/eslint-utils": { + "version": "4.4.0", + "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.4.0.tgz", + "integrity": "sha512-1/sA4dwrzBAyeUoQ6oxahHKmrZvsnLCg4RfxW3ZFGGmQkSNQPFNLV9CUEFQP1x9EYXHTo5p6xdhZM1Ne9p/AfA==", + "dev": true, + "requires": { + "eslint-visitor-keys": "^3.3.0" + } + }, + "@eslint-community/regexpp": { + "version": "4.5.1", + "dev": true + }, + "@eslint/eslintrc": { + "version": "2.0.3", + "dev": true, + "requires": { + "ajv": "^6.12.4", + "debug": "^4.3.2", + "espree": "^9.5.2", + "globals": "^13.19.0", + "ignore": "^5.2.0", + "import-fresh": "^3.2.1", + "js-yaml": "^4.1.0", + "minimatch": "^3.1.2", + "strip-json-comments": "^3.1.1" + } + }, + "@eslint/js": { + "version": "8.43.0", + "dev": true + }, + "@humanwhocodes/config-array": { + "version": "0.11.10", + "resolved": "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.11.10.tgz", + "integrity": "sha512-KVVjQmNUepDVGXNuoRRdmmEjruj0KfiGSbS8LVc12LMsWDQzRXJ0qdhN8L8uUigKpfEHRhlaQFY0ib1tnUbNeQ==", + "dev": true, + "requires": { + "@humanwhocodes/object-schema": "^1.2.1", + "debug": "^4.1.1", + "minimatch": "^3.0.5" + } + }, + "@humanwhocodes/module-importer": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz", + "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==", + "dev": true + }, + "@humanwhocodes/object-schema": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-1.2.1.tgz", + "integrity": "sha512-ZnQMnLV4e7hDlUvw8H+U8ASL02SS2Gn6+9Ac3wGGLIe7+je2AeAOxPY+izIPJDfFDb7eDjev0Us8MO1iFRN8hA==", + "dev": true + }, + "@istanbuljs/load-nyc-config": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@istanbuljs/load-nyc-config/-/load-nyc-config-1.1.0.tgz", + "integrity": "sha512-VjeHSlIzpv/NyD3N0YuHfXOPDIixcA1q2ZV98wsMqcYlPmv2n3Yb2lYP9XMElnaFVXg5A7YLTeLu6V84uQDjmQ==", + "dev": true, + "requires": { + "camelcase": "^5.3.1", + "find-up": "^4.1.0", + "get-package-type": "^0.1.0", + "js-yaml": "^3.13.1", + "resolve-from": "^5.0.0" + }, + "dependencies": { + "argparse": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz", + "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==", + "dev": true, + "requires": { + "sprintf-js": "~1.0.2" + } + }, + "camelcase": { + "version": "5.3.1", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz", + "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==", + "dev": true + }, + "js-yaml": { + "version": "3.14.1", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz", + "integrity": "sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==", + "dev": true, + "requires": { + "argparse": "^1.0.7", + "esprima": "^4.0.0" + } + } + } + }, + "@istanbuljs/schema": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/@istanbuljs/schema/-/schema-0.1.3.tgz", + "integrity": "sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==", + "dev": true + }, + "@jest/console": { + "version": "29.5.0", + "dev": true, + "requires": { + "@jest/types": "^29.5.0", + "@types/node": "*", + "chalk": "^4.0.0", + "jest-message-util": "^29.5.0", + "jest-util": "^29.5.0", + "slash": "^3.0.0" + } + }, + "@jest/core": { + "version": "29.5.0", + "dev": true, + "requires": { + "@jest/console": "^29.5.0", + "@jest/reporters": "^29.5.0", + "@jest/test-result": "^29.5.0", + "@jest/transform": "^29.5.0", + "@jest/types": "^29.5.0", + "@types/node": "*", + "ansi-escapes": "^4.2.1", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "exit": "^0.1.2", + "graceful-fs": "^4.2.9", + "jest-changed-files": "^29.5.0", + "jest-config": "^29.5.0", + "jest-haste-map": "^29.5.0", + "jest-message-util": "^29.5.0", + "jest-regex-util": "^29.4.3", + "jest-resolve": "^29.5.0", + "jest-resolve-dependencies": "^29.5.0", + "jest-runner": "^29.5.0", + "jest-runtime": "^29.5.0", + "jest-snapshot": "^29.5.0", + "jest-util": "^29.5.0", + "jest-validate": "^29.5.0", + "jest-watcher": "^29.5.0", + "micromatch": "^4.0.4", + "pretty-format": "^29.5.0", + "slash": "^3.0.0", + "strip-ansi": "^6.0.0" + } + }, + "@jest/environment": { + "version": "29.5.0", + "dev": true, + "requires": { + "@jest/fake-timers": "^29.5.0", + "@jest/types": "^29.5.0", + "@types/node": "*", + "jest-mock": "^29.5.0" + } + }, + "@jest/expect": { + "version": "29.5.0", + "dev": true, + "requires": { + "expect": "^29.5.0", + "jest-snapshot": "^29.5.0" + } + }, + "@jest/expect-utils": { + "version": "29.5.0", + "dev": true, + "requires": { + "jest-get-type": "^29.4.3" + } + }, + "@jest/fake-timers": { + "version": "29.5.0", + "dev": true, + "requires": { + "@jest/types": "^29.5.0", + "@sinonjs/fake-timers": "^10.0.2", + "@types/node": "*", + "jest-message-util": "^29.5.0", + "jest-mock": "^29.5.0", + "jest-util": "^29.5.0" + } + }, + "@jest/globals": { + "version": "29.5.0", + "dev": true, + "requires": { + "@jest/environment": "^29.5.0", + "@jest/expect": "^29.5.0", + "@jest/types": "^29.5.0", + "jest-mock": "^29.5.0" + } + }, + "@jest/reporters": { + "version": "29.5.0", + "dev": true, + "requires": { + "@bcoe/v8-coverage": "^0.2.3", + "@jest/console": "^29.5.0", + "@jest/test-result": "^29.5.0", + "@jest/transform": "^29.5.0", + "@jest/types": "^29.5.0", + "@jridgewell/trace-mapping": "^0.3.15", + "@types/node": "*", + "chalk": "^4.0.0", + "collect-v8-coverage": "^1.0.0", + "exit": "^0.1.2", + "glob": "^7.1.3", + "graceful-fs": "^4.2.9", + "istanbul-lib-coverage": "^3.0.0", + "istanbul-lib-instrument": "^5.1.0", + "istanbul-lib-report": "^3.0.0", + "istanbul-lib-source-maps": "^4.0.0", + "istanbul-reports": "^3.1.3", + "jest-message-util": "^29.5.0", + "jest-util": "^29.5.0", + "jest-worker": "^29.5.0", + "slash": "^3.0.0", + "string-length": "^4.0.1", + "strip-ansi": "^6.0.0", + "v8-to-istanbul": "^9.0.1" + } + }, + "@jest/schemas": { + "version": "29.4.3", + "dev": true, + "requires": { + "@sinclair/typebox": "^0.25.16" + } + }, + "@jest/source-map": { + "version": "29.4.3", + "dev": true, + "requires": { + "@jridgewell/trace-mapping": "^0.3.15", + "callsites": "^3.0.0", + "graceful-fs": "^4.2.9" + } + }, + "@jest/test-result": { + "version": "29.5.0", + "dev": true, + "requires": { + "@jest/console": "^29.5.0", + "@jest/types": "^29.5.0", + "@types/istanbul-lib-coverage": "^2.0.0", + "collect-v8-coverage": "^1.0.0" + } + }, + "@jest/test-sequencer": { + "version": "29.5.0", + "dev": true, + "requires": { + "@jest/test-result": "^29.5.0", + "graceful-fs": "^4.2.9", + "jest-haste-map": "^29.5.0", + "slash": "^3.0.0" + } + }, + "@jest/transform": { + "version": "29.5.0", + "dev": true, + "requires": { + "@babel/core": "^7.11.6", + "@jest/types": "^29.5.0", + "@jridgewell/trace-mapping": "^0.3.15", + "babel-plugin-istanbul": "^6.1.1", + "chalk": "^4.0.0", + "convert-source-map": "^2.0.0", + "fast-json-stable-stringify": "^2.1.0", + "graceful-fs": "^4.2.9", + "jest-haste-map": "^29.5.0", + "jest-regex-util": "^29.4.3", + "jest-util": "^29.5.0", + "micromatch": "^4.0.4", + "pirates": "^4.0.4", + "slash": "^3.0.0", + "write-file-atomic": "^4.0.2" + }, + "dependencies": { + "convert-source-map": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz", + "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==", + "dev": true + } + } + }, + "@jest/types": { + "version": "29.5.0", + "dev": true, + "requires": { + "@jest/schemas": "^29.4.3", + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^17.0.8", + "chalk": "^4.0.0" + } + }, + "@jridgewell/gen-mapping": { + "version": "0.3.3", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.3.tgz", + "integrity": "sha512-HLhSWOLRi875zjjMG/r+Nv0oCW8umGb0BgEhyX3dDX3egwZtB8PqLnjz3yedt8R5StBrzcg4aBpnh8UA9D1BoQ==", + "dev": true, + "requires": { + "@jridgewell/set-array": "^1.0.1", + "@jridgewell/sourcemap-codec": "^1.4.10", + "@jridgewell/trace-mapping": "^0.3.9" + }, + "dependencies": { + "@jridgewell/sourcemap-codec": { + "version": "1.4.15", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz", + "integrity": "sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg==", + "dev": true + } + } + }, + "@jridgewell/resolve-uri": { + "version": "3.1.0", + "dev": true + }, + "@jridgewell/set-array": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.1.2.tgz", + "integrity": "sha512-xnkseuNADM0gt2bs+BvhO0p78Mk762YnZdsuzFV018NoG1Sj1SCQvpSqa7XUaTam5vAGasABV9qXASMKnFMwMw==", + "dev": true + }, + "@jridgewell/sourcemap-codec": { + "version": "1.4.14", + "dev": true + }, + "@jridgewell/trace-mapping": { + "version": "0.3.18", + "dev": true, + "requires": { + "@jridgewell/resolve-uri": "3.1.0", + "@jridgewell/sourcemap-codec": "1.4.14" + } + }, + "@microsoft/tsdoc": { + "version": "0.14.2", + "resolved": "https://registry.npmjs.org/@microsoft/tsdoc/-/tsdoc-0.14.2.tgz", + "integrity": "sha512-9b8mPpKrfeGRuhFH5iO1iwCLeIIsV6+H1sRfxbkoGXIyQE2BTsPd9zqSqQJ+pv5sJ/hT5M1zvOFL02MnEezFug==" + }, + "@nodelib/fs.scandir": { + "version": "2.1.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", + "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==", + "requires": { + "@nodelib/fs.stat": "2.0.5", + "run-parallel": "^1.1.9" + } + }, + "@nodelib/fs.stat": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz", + "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==" + }, + "@nodelib/fs.walk": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz", + "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==", + "requires": { + "@nodelib/fs.scandir": "2.1.5", + "fastq": "^1.6.0" + } + }, + "@sinclair/typebox": { + "version": "0.25.24", + "dev": true + }, + "@sinonjs/commons": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/@sinonjs/commons/-/commons-3.0.0.tgz", + "integrity": "sha512-jXBtWAF4vmdNmZgD5FoKsVLv3rPgDnLgPbU84LIJ3otV44vJlDRokVng5v8NFJdCf/da9legHcKaRuZs4L7faA==", + "dev": true, + "requires": { + "type-detect": "4.0.8" + } + }, + "@sinonjs/fake-timers": { + "version": "10.3.0", + "resolved": "https://registry.npmjs.org/@sinonjs/fake-timers/-/fake-timers-10.3.0.tgz", + "integrity": "sha512-V4BG07kuYSUkTCSBHG8G8TNhM+F19jXFWnQtzj+we8DrkpSBCee9Z3Ms8yiGer/dlmhe35/Xdgyo3/0rQKg7YA==", + "dev": true, + "requires": { + "@sinonjs/commons": "^3.0.0" + } + }, + "@ts-morph/common": { + "version": "0.21.0", + "resolved": "https://registry.npmjs.org/@ts-morph/common/-/common-0.21.0.tgz", + "integrity": "sha512-ES110Mmne5Vi4ypUKrtVQfXFDtCsDXiUiGxF6ILVlE90dDD4fdpC1LSjydl/ml7xJWKSDZwUYD2zkOePMSrPBA==", + "requires": { + "fast-glob": "^3.2.12", + "minimatch": "^7.4.3", + "mkdirp": "^2.1.6", + "path-browserify": "^1.0.1" + }, + "dependencies": { + "brace-expansion": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", + "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", + "requires": { + "balanced-match": "^1.0.0" + } + }, + "minimatch": { + "version": "7.4.6", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-7.4.6.tgz", + "integrity": "sha512-sBz8G/YjVniEz6lKPNpKxXwazJe4c19fEfV2GDMX6AjFz+MX9uDWIZW8XreVhkFW3fkIdTv/gxWr/Kks5FFAVw==", + "requires": { + "brace-expansion": "^2.0.1" + } + } + } + }, + "@types/babel__core": { + "version": "7.20.1", + "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.1.tgz", + "integrity": "sha512-aACu/U/omhdk15O4Nfb+fHgH/z3QsfQzpnvRZhYhThms83ZnAOZz7zZAWO7mn2yyNQaA4xTO8GLK3uqFU4bYYw==", + "dev": true, + "requires": { + "@babel/parser": "^7.20.7", + "@babel/types": "^7.20.7", + "@types/babel__generator": "*", + "@types/babel__template": "*", + "@types/babel__traverse": "*" + } + }, + "@types/babel__generator": { + "version": "7.6.4", + "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.6.4.tgz", + "integrity": "sha512-tFkciB9j2K755yrTALxD44McOrk+gfpIpvC3sxHjRawj6PfnQxrse4Clq5y/Rq+G3mrBurMax/lG8Qn2t9mSsg==", + "dev": true, + "requires": { + "@babel/types": "^7.0.0" + } + }, + "@types/babel__template": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.1.tgz", + "integrity": "sha512-azBFKemX6kMg5Io+/rdGT0dkGreboUVR0Cdm3fz9QJWpaQGJRQXl7C+6hOTCZcMll7KFyEQpgbYI2lHdsS4U7g==", + "dev": true, + "requires": { + "@babel/parser": "^7.1.0", + "@babel/types": "^7.0.0" + } + }, + "@types/babel__traverse": { + "version": "7.20.1", + "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.20.1.tgz", + "integrity": "sha512-MitHFXnhtgwsGZWtT68URpOvLN4EREih1u3QtQiN4VdAxWKRVvGCSvw/Qth0M0Qq3pJpnGOu5JaM/ydK7OGbqg==", + "dev": true, + "requires": { + "@babel/types": "^7.20.7" + } + }, + "@types/graceful-fs": { + "version": "4.1.6", + "resolved": "https://registry.npmjs.org/@types/graceful-fs/-/graceful-fs-4.1.6.tgz", + "integrity": "sha512-Sig0SNORX9fdW+bQuTEovKj3uHcUL6LQKbCrrqb1X7J6/ReAbhCXRAhc+SMejhLELFj2QcyuxmUooZ4bt5ReSw==", + "dev": true, + "requires": { + "@types/node": "*" + } + }, + "@types/istanbul-lib-coverage": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.4.tgz", + "integrity": "sha512-z/QT1XN4K4KYuslS23k62yDIDLwLFkzxOuMplDtObz0+y7VqJCaO2o+SPwHCvLFZh7xazvvoor2tA/hPz9ee7g==", + "dev": true + }, + "@types/istanbul-lib-report": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/@types/istanbul-lib-report/-/istanbul-lib-report-3.0.0.tgz", + "integrity": "sha512-plGgXAPfVKFoYfa9NpYDAkseG+g6Jr294RqeqcqDixSbU34MZVJRi/P+7Y8GDpzkEwLaGZZOpKIEmeVZNtKsrg==", + "dev": true, + "requires": { + "@types/istanbul-lib-coverage": "*" + } + }, + "@types/istanbul-reports": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/@types/istanbul-reports/-/istanbul-reports-3.0.1.tgz", + "integrity": "sha512-c3mAZEuK0lvBp8tmuL74XRKn1+y2dcwOUpH7x4WrF6gk1GIgiluDRgMYQtw2OFcBvAJWlt6ASU3tSqxp0Uu0Aw==", + "dev": true, + "requires": { + "@types/istanbul-lib-report": "*" + } + }, + "@types/json-schema": { + "version": "7.0.12", + "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.12.tgz", + "integrity": "sha512-Hr5Jfhc9eYOQNPYO5WLDq/n4jqijdHNlDXjuAQkkt+mWdQR+XJToOHrsD4cPaMXpn6KO7y2+wM8AZEs8VpBLVA==", + "dev": true + }, + "@types/json5": { + "version": "0.0.29", + "resolved": "https://registry.npmjs.org/@types/json5/-/json5-0.0.29.tgz", + "integrity": "sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ==", + "dev": true + }, + "@types/node": { + "version": "20.3.1", + "dev": true + }, + "@types/prettier": { + "version": "2.7.3", + "dev": true + }, + "@types/semver": { + "version": "7.5.0", + "resolved": "https://registry.npmjs.org/@types/semver/-/semver-7.5.0.tgz", + "integrity": "sha512-G8hZ6XJiHnuhQKR7ZmysCeJWE08o8T0AXtk5darsCaTVsYZhhgUrq53jizaR2FvsoeCwJhlmwTjkXBY5Pn/ZHw==", + "dev": true + }, + "@types/stack-utils": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/@types/stack-utils/-/stack-utils-2.0.1.tgz", + "integrity": "sha512-Hl219/BT5fLAaz6NDkSuhzasy49dwQS/DSdu4MdggFB8zcXv7vflBI3xp7FEmkmdDkBUI2bPUNeMttp2knYdxw==", + "dev": true + }, + "@types/yargs": { + "version": "17.0.24", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-17.0.24.tgz", + "integrity": "sha512-6i0aC7jV6QzQB8ne1joVZ0eSFIstHsCrobmOtghM11yGlH0j43FKL2UhWdELkyps0zuf7qVTUVCCR+tgSlyLLw==", + "dev": true, + "requires": { + "@types/yargs-parser": "*" + } + }, + "@types/yargs-parser": { + "version": "21.0.0", + "resolved": "https://registry.npmjs.org/@types/yargs-parser/-/yargs-parser-21.0.0.tgz", + "integrity": "sha512-iO9ZQHkZxHn4mSakYV0vFHAVDyEOIJQrV2uZ06HxEPcx+mt8swXoZHIbaaJ2crJYFfErySgktuTZ3BeLz+XmFA==", + "dev": true + }, + "@typescript-eslint/eslint-plugin": { + "version": "5.60.0", + "dev": true, + "requires": { + "@eslint-community/regexpp": "^4.4.0", + "@typescript-eslint/scope-manager": "5.60.0", + "@typescript-eslint/type-utils": "5.60.0", + "@typescript-eslint/utils": "5.60.0", + "debug": "^4.3.4", + "grapheme-splitter": "^1.0.4", + "ignore": "^5.2.0", + "natural-compare-lite": "^1.4.0", + "semver": "^7.3.7", + "tsutils": "^3.21.0" + }, + "dependencies": { + "semver": { + "version": "7.5.2", + "dev": true, + "requires": { + "lru-cache": "^6.0.0" + } + } + } + }, + "@typescript-eslint/parser": { + "version": "5.60.0", + "dev": true, + "requires": { + "@typescript-eslint/scope-manager": "5.60.0", + "@typescript-eslint/types": "5.60.0", + "@typescript-eslint/typescript-estree": "5.60.0", + "debug": "^4.3.4" + } + }, + "@typescript-eslint/scope-manager": { + "version": "5.60.0", + "dev": true, + "requires": { + "@typescript-eslint/types": "5.60.0", + "@typescript-eslint/visitor-keys": "5.60.0" + } + }, + "@typescript-eslint/type-utils": { + "version": "5.60.0", + "dev": true, + "requires": { + "@typescript-eslint/typescript-estree": "5.60.0", + "@typescript-eslint/utils": "5.60.0", + "debug": "^4.3.4", + "tsutils": "^3.21.0" + } + }, + "@typescript-eslint/types": { + "version": "5.60.0", + "dev": true + }, + "@typescript-eslint/typescript-estree": { + "version": "5.60.0", + "dev": true, + "requires": { + "@typescript-eslint/types": "5.60.0", + "@typescript-eslint/visitor-keys": "5.60.0", + "debug": "^4.3.4", + "globby": "^11.1.0", + "is-glob": "^4.0.3", + "semver": "^7.3.7", + "tsutils": "^3.21.0" + }, + "dependencies": { + "semver": { + "version": "7.5.2", + "dev": true, + "requires": { + "lru-cache": "^6.0.0" + } + } + } + }, + "@typescript-eslint/utils": { + "version": "5.60.0", + "dev": true, + "requires": { + "@eslint-community/eslint-utils": "^4.2.0", + "@types/json-schema": "^7.0.9", + "@types/semver": "^7.3.12", + "@typescript-eslint/scope-manager": "5.60.0", + "@typescript-eslint/types": "5.60.0", + "@typescript-eslint/typescript-estree": "5.60.0", + "eslint-scope": "^5.1.1", + "semver": "^7.3.7" + }, + "dependencies": { + "eslint-scope": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-5.1.1.tgz", + "integrity": "sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==", + "dev": true, + "requires": { + "esrecurse": "^4.3.0", + "estraverse": "^4.1.1" + } + }, + "estraverse": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz", + "integrity": "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==", + "dev": true + }, + "semver": { + "version": "7.5.2", + "dev": true, + "requires": { + "lru-cache": "^6.0.0" + } + } + } + }, + "@typescript-eslint/visitor-keys": { + "version": "5.60.0", + "dev": true, + "requires": { + "@typescript-eslint/types": "5.60.0", + "eslint-visitor-keys": "^3.3.0" + } + }, + "acorn": { + "version": "8.9.0", + "dev": true + }, + "acorn-jsx": { + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz", + "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==", + "dev": true, + "requires": {} + }, + "ajv": { + "version": "6.12.6", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz", + "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==", + "dev": true, + "requires": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + } + }, + "algo-msgpack-with-bigint": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/algo-msgpack-with-bigint/-/algo-msgpack-with-bigint-2.1.1.tgz", + "integrity": "sha512-F1tGh056XczEaEAqu7s+hlZUDWwOBT70Eq0lfMpBP2YguSQVyxRbprLq5rELXKQOyOaixTWYhMeMQMzP0U5FoQ==" + }, + "algosdk": { + "version": "2.7.0", + "resolved": "https://registry.npmjs.org/algosdk/-/algosdk-2.7.0.tgz", + "integrity": "sha512-sBE9lpV7bup3rZ+q2j3JQaFAE9JwZvjWKX00vPlG8e9txctXbgLL56jZhSWZndqhDI9oI+0P4NldkuQIWdrUyg==", + "requires": { + "algo-msgpack-with-bigint": "^2.1.1", + "buffer": "^6.0.3", + "hi-base32": "^0.5.1", + "js-sha256": "^0.9.0", + "js-sha3": "^0.8.0", + "js-sha512": "^0.8.0", + "json-bigint": "^1.0.0", + "tweetnacl": "^1.0.3", + "vlq": "^2.0.4" + } + }, + "ansi-escapes": { + "version": "4.3.2", + "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.2.tgz", + "integrity": "sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==", + "dev": true, + "requires": { + "type-fest": "^0.21.3" + }, + "dependencies": { + "type-fest": { + "version": "0.21.3", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.21.3.tgz", + "integrity": "sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==", + "dev": true + } + } + }, + "ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "dev": true + }, + "ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "requires": { + "color-convert": "^2.0.1" + } + }, + "anymatch": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz", + "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==", + "dev": true, + "requires": { + "normalize-path": "^3.0.0", + "picomatch": "^2.0.4" + } + }, + "argparse": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==" + }, + "array-buffer-byte-length": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/array-buffer-byte-length/-/array-buffer-byte-length-1.0.0.tgz", + "integrity": "sha512-LPuwb2P+NrQw3XhxGc36+XSvuBPopovXYTR9Ew++Du9Yb/bx5AzBfrIsBoj0EZUifjQU+sHL21sseZ3jerWO/A==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "is-array-buffer": "^3.0.1" + } + }, + "array-includes": { + "version": "3.1.6", + "resolved": "https://registry.npmjs.org/array-includes/-/array-includes-3.1.6.tgz", + "integrity": "sha512-sgTbLvL6cNnw24FnbaDyjmvddQ2ML8arZsgaJhoABMoplz/4QRhtrYS+alr1BUM1Bwp6dhx8vVCBSLG+StwOFw==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4", + "get-intrinsic": "^1.1.3", + "is-string": "^1.0.7" + } + }, + "array-union": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz", + "integrity": "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==", + "dev": true + }, + "array.prototype.flat": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/array.prototype.flat/-/array.prototype.flat-1.3.1.tgz", + "integrity": "sha512-roTU0KWIOmJ4DRLmwKd19Otg0/mT3qPNt0Qb3GWW8iObuZXxrjB/pzn0R3hqpRSWg4HCwqx+0vwOnWnvlOyeIA==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4", + "es-shim-unscopables": "^1.0.0" + } + }, + "array.prototype.flatmap": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/array.prototype.flatmap/-/array.prototype.flatmap-1.3.1.tgz", + "integrity": "sha512-8UGn9O1FDVvMNB0UlLv4voxRMze7+FpHyF5mSMRjWHUMlpoDViniy05870VlxhfgTnLbpuwTzvD76MTtWxB/mQ==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4", + "es-shim-unscopables": "^1.0.0" + } + }, + "available-typed-arrays": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.5.tgz", + "integrity": "sha512-DMD0KiN46eipeziST1LPP/STfDU0sufISXmjSgvVsoU2tqxctQeASejWcfNtxYKqETM1UxQ8sp2OrSBWpHY6sw==", + "dev": true + }, + "babel-jest": { + "version": "29.5.0", + "dev": true, + "requires": { + "@jest/transform": "^29.5.0", + "@types/babel__core": "^7.1.14", + "babel-plugin-istanbul": "^6.1.1", + "babel-preset-jest": "^29.5.0", + "chalk": "^4.0.0", + "graceful-fs": "^4.2.9", + "slash": "^3.0.0" + } + }, + "babel-plugin-istanbul": { + "version": "6.1.1", + "resolved": "https://registry.npmjs.org/babel-plugin-istanbul/-/babel-plugin-istanbul-6.1.1.tgz", + "integrity": "sha512-Y1IQok9821cC9onCx5otgFfRm7Lm+I+wwxOx738M/WLPZ9Q42m4IG5W0FNX8WLL2gYMZo3JkuXIH2DOpWM+qwA==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.0.0", + "@istanbuljs/load-nyc-config": "^1.0.0", + "@istanbuljs/schema": "^0.1.2", + "istanbul-lib-instrument": "^5.0.4", + "test-exclude": "^6.0.0" + } + }, + "babel-plugin-jest-hoist": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/babel-plugin-jest-hoist/-/babel-plugin-jest-hoist-29.5.0.tgz", + "integrity": "sha512-zSuuuAlTMT4mzLj2nPnUm6fsE6270vdOfnpbJ+RmruU75UhLFvL0N2NgI7xpeS7NaB6hGqmd5pVpGTDYvi4Q3w==", + "dev": true, + "requires": { + "@babel/template": "^7.3.3", + "@babel/types": "^7.3.3", + "@types/babel__core": "^7.1.14", + "@types/babel__traverse": "^7.0.6" + } + }, + "babel-preset-current-node-syntax": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/babel-preset-current-node-syntax/-/babel-preset-current-node-syntax-1.0.1.tgz", + "integrity": "sha512-M7LQ0bxarkxQoN+vz5aJPsLBn77n8QgTFmo8WK0/44auK2xlCXrYcUxHFxgU7qW5Yzw/CjmLRK2uJzaCd7LvqQ==", + "dev": true, + "requires": { + "@babel/plugin-syntax-async-generators": "^7.8.4", + "@babel/plugin-syntax-bigint": "^7.8.3", + "@babel/plugin-syntax-class-properties": "^7.8.3", + "@babel/plugin-syntax-import-meta": "^7.8.3", + "@babel/plugin-syntax-json-strings": "^7.8.3", + "@babel/plugin-syntax-logical-assignment-operators": "^7.8.3", + "@babel/plugin-syntax-nullish-coalescing-operator": "^7.8.3", + "@babel/plugin-syntax-numeric-separator": "^7.8.3", + "@babel/plugin-syntax-object-rest-spread": "^7.8.3", + "@babel/plugin-syntax-optional-catch-binding": "^7.8.3", + "@babel/plugin-syntax-optional-chaining": "^7.8.3", + "@babel/plugin-syntax-top-level-await": "^7.8.3" + } + }, + "babel-preset-jest": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/babel-preset-jest/-/babel-preset-jest-29.5.0.tgz", + "integrity": "sha512-JOMloxOqdiBSxMAzjRaH023/vvcaSaec49zvg+2LmNsktC7ei39LTJGw02J+9uUtTZUq6xbLyJ4dxe9sSmIuAg==", + "dev": true, + "requires": { + "babel-plugin-jest-hoist": "^29.5.0", + "babel-preset-current-node-syntax": "^1.0.0" + } + }, + "balanced-match": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", + "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==" + }, + "base64-js": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz", + "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==" + }, + "bignumber.js": { + "version": "9.1.1", + "resolved": "https://registry.npmjs.org/bignumber.js/-/bignumber.js-9.1.1.tgz", + "integrity": "sha512-pHm4LsMJ6lzgNGVfZHjMoO8sdoRhOzOH4MLmY65Jg70bpxCKu5iOHNJyfF6OyvYw7t8Fpf35RuzUyqnQsj8Vig==" + }, + "brace-expansion": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", + "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "dev": true, + "requires": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "braces": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz", + "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==", + "requires": { + "fill-range": "^7.0.1" + } + }, + "browserslist": { + "version": "4.21.9", + "dev": true, + "requires": { + "caniuse-lite": "^1.0.30001503", + "electron-to-chromium": "^1.4.431", + "node-releases": "^2.0.12", + "update-browserslist-db": "^1.0.11" + } + }, + "bs-logger": { + "version": "0.2.6", + "resolved": "https://registry.npmjs.org/bs-logger/-/bs-logger-0.2.6.tgz", + "integrity": "sha512-pd8DCoxmbgc7hyPKOvxtqNcjYoOsABPQdcCUjGp3d42VR2CX1ORhk2A87oqqu5R1kk+76nsxZupkmyd+MVtCog==", + "dev": true, + "requires": { + "fast-json-stable-stringify": "2.x" + } + }, + "bser": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/bser/-/bser-2.1.1.tgz", + "integrity": "sha512-gQxTNE/GAfIIrmHLUE3oJyp5FO6HRBfhjnw4/wMmA63ZGDJnWBmgY/lyQBpnDUkGmAhbSe39tx2d/iTOAfglwQ==", + "dev": true, + "requires": { + "node-int64": "^0.4.0" + } + }, + "buffer": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/buffer/-/buffer-6.0.3.tgz", + "integrity": "sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==", + "requires": { + "base64-js": "^1.3.1", + "ieee754": "^1.2.1" + } + }, + "buffer-from": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz", + "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==", + "dev": true + }, + "call-bind": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.2.tgz", + "integrity": "sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==", + "dev": true, + "requires": { + "function-bind": "^1.1.1", + "get-intrinsic": "^1.0.2" + } + }, + "callsites": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz", + "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==", + "dev": true + }, + "camel-case": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/camel-case/-/camel-case-4.1.2.tgz", + "integrity": "sha512-gxGWBrTT1JuMx6R+o5PTXMmUnhnVzLQ9SNutD4YqKtI6ap897t3tKECYla6gCWEkplXnlNybEkZg9GEGxKFCgw==", + "dev": true, + "requires": { + "pascal-case": "^3.1.2", + "tslib": "^2.0.3" + } + }, + "camelcase": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz", + "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==", + "dev": true + }, + "caniuse-lite": { + "version": "1.0.30001505", + "dev": true + }, + "capital-case": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/capital-case/-/capital-case-1.0.4.tgz", + "integrity": "sha512-ds37W8CytHgwnhGGTi88pcPyR15qoNkOpYwmMMfnWqqWgESapLqvDx6huFjQ5vqWSn2Z06173XNA7LtMOeUh1A==", + "dev": true, + "requires": { + "no-case": "^3.0.4", + "tslib": "^2.0.3", + "upper-case-first": "^2.0.2" + } + }, + "chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dev": true, + "requires": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + } + }, + "change-case": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/change-case/-/change-case-4.1.2.tgz", + "integrity": "sha512-bSxY2ws9OtviILG1EiY5K7NNxkqg/JnRnFxLtKQ96JaviiIxi7djMrSd0ECT9AC+lttClmYwKw53BWpOMblo7A==", + "dev": true, + "requires": { + "camel-case": "^4.1.2", + "capital-case": "^1.0.4", + "constant-case": "^3.0.4", + "dot-case": "^3.0.4", + "header-case": "^2.0.4", + "no-case": "^3.0.4", + "param-case": "^3.0.4", + "pascal-case": "^3.1.2", + "path-case": "^3.0.4", + "sentence-case": "^3.0.4", + "snake-case": "^3.0.4", + "tslib": "^2.0.3" + } + }, + "char-regex": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/char-regex/-/char-regex-1.0.2.tgz", + "integrity": "sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw==", + "dev": true + }, + "ci-info": { + "version": "3.8.0", + "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-3.8.0.tgz", + "integrity": "sha512-eXTggHWSooYhq49F2opQhuHWgzucfF2YgODK4e1566GQs5BIfP30B0oenwBJHfWxAs2fyPB1s7Mg949zLf61Yw==", + "dev": true + }, + "cjs-module-lexer": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/cjs-module-lexer/-/cjs-module-lexer-1.2.3.tgz", + "integrity": "sha512-0TNiGstbQmCFwt4akjjBg5pLRTSyj/PkWQ1ZoO2zntmg9yLqSRxwEa4iCfQLGjqhiqBfOJa7W/E8wfGrTDmlZQ==", + "dev": true + }, + "cliui": { + "version": "8.0.1", + "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz", + "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==", + "dev": true, + "requires": { + "string-width": "^4.2.0", + "strip-ansi": "^6.0.1", + "wrap-ansi": "^7.0.0" + } + }, + "co": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/co/-/co-4.6.0.tgz", + "integrity": "sha512-QVb0dM5HvG+uaxitm8wONl7jltx8dqhfU33DcqtOZcLSVIKSDDLDi7+0LbAKiyI8hD9u42m2YxXSkMGWThaecQ==", + "dev": true + }, + "code-block-writer": { + "version": "12.0.0", + "resolved": "https://registry.npmjs.org/code-block-writer/-/code-block-writer-12.0.0.tgz", + "integrity": "sha512-q4dMFMlXtKR3XNBHyMHt/3pwYNA69EDk00lloMOaaUMKPUXBw6lpXtbu3MMVG6/uOihGnRDOlkyqsONEUj60+w==" + }, + "collect-v8-coverage": { + "version": "1.0.1", + "dev": true + }, + "color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "requires": { + "color-name": "~1.1.4" + } + }, + "color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true + }, + "commander": { + "version": "10.0.1", + "resolved": "https://registry.npmjs.org/commander/-/commander-10.0.1.tgz", + "integrity": "sha512-y4Mg2tXshplEbSGzx7amzPwKKOCGuoSRP/CjEdwwk0FOGlUbq6lKuoyDZTNZkmxHdJtp54hdfY/JUrdL7Xfdug==", + "dev": true + }, + "concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==", + "dev": true + }, + "confusing-browser-globals": { + "version": "1.0.11", + "resolved": "https://registry.npmjs.org/confusing-browser-globals/-/confusing-browser-globals-1.0.11.tgz", + "integrity": "sha512-JsPKdmh8ZkmnHxDk55FZ1TqVLvEQTvoByJZRN9jzI0UjxK/QgAmsphz7PGtqgPieQZ/CQcHWXCR7ATDNhGe+YA==", + "dev": true + }, + "constant-case": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/constant-case/-/constant-case-3.0.4.tgz", + "integrity": "sha512-I2hSBi7Vvs7BEuJDr5dDHfzb/Ruj3FyvFyh7KLilAjNQw3Be+xgqUBA2W6scVEcL0hL1dwPRtIqEPVUCKkSsyQ==", + "dev": true, + "requires": { + "no-case": "^3.0.4", + "tslib": "^2.0.3", + "upper-case": "^2.0.2" + } + }, + "convert-source-map": { + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.9.0.tgz", + "integrity": "sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==", + "dev": true + }, + "cross-spawn": { + "version": "7.0.3", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz", + "integrity": "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==", + "dev": true, + "requires": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1" + } + }, + "debug": { + "version": "4.3.4", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz", + "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==", + "dev": true, + "requires": { + "ms": "2.1.2" + } + }, + "dedent": { + "version": "0.7.0", + "dev": true + }, + "deep-is": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz", + "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==", + "dev": true + }, + "deepmerge": { + "version": "4.3.1", + "resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-4.3.1.tgz", + "integrity": "sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==", + "dev": true + }, + "define-properties": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.0.tgz", + "integrity": "sha512-xvqAVKGfT1+UAvPwKTVw/njhdQ8ZhXK4lI0bCIuCMrp2up9nPnaDftrLtmpTazqd1o+UY4zgzU+avtMbDP+ldA==", + "dev": true, + "requires": { + "has-property-descriptors": "^1.0.0", + "object-keys": "^1.1.1" + } + }, + "detect-newline": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/detect-newline/-/detect-newline-3.1.0.tgz", + "integrity": "sha512-TLz+x/vEXm/Y7P7wn1EJFNLxYpUD4TgMosxY6fAVJUnJMbupHBOncxyWUG9OpTaH9EBD7uFI5LfEgmMOc54DsA==", + "dev": true + }, + "diff-sequences": { + "version": "29.4.3", + "resolved": "https://registry.npmjs.org/diff-sequences/-/diff-sequences-29.4.3.tgz", + "integrity": "sha512-ofrBgwpPhCD85kMKtE9RYFFq6OC1A89oW2vvgWZNCwxrUpRUILopY7lsYyMDSjc8g6U6aiO0Qubg6r4Wgt5ZnA==", + "dev": true + }, + "dir-glob": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz", + "integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==", + "dev": true, + "requires": { + "path-type": "^4.0.0" + } + }, + "doctrine": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-2.1.0.tgz", + "integrity": "sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==", + "dev": true, + "requires": { + "esutils": "^2.0.2" + } + }, + "dot-case": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/dot-case/-/dot-case-3.0.4.tgz", + "integrity": "sha512-Kv5nKlh6yRrdrGvxeJ2e5y2eRUpkUosIW4A2AS38zwSz27zu7ufDwQPi5Jhs3XAlGNetl3bmnGhQsMtkKJnj3w==", + "dev": true, + "requires": { + "no-case": "^3.0.4", + "tslib": "^2.0.3" + } + }, + "dotenv": { + "version": "16.3.1", + "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.3.1.tgz", + "integrity": "sha512-IPzF4w4/Rd94bA9imS68tZBaYyBWSCE47V1RGuMrB94iyTOIEwRmVL2x/4An+6mETpLrKJ5hQkB8W4kFAadeIQ==" + }, + "electron-to-chromium": { + "version": "1.4.435", + "dev": true + }, + "emittery": { + "version": "0.13.1", + "resolved": "https://registry.npmjs.org/emittery/-/emittery-0.13.1.tgz", + "integrity": "sha512-DeWwawk6r5yR9jFgnDKYt4sLS0LmHJJi3ZOnb5/JdbYwj3nW+FxQnHIjhBKz8YLC7oRNPVM9NQ47I3CVx34eqQ==", + "dev": true + }, + "emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "dev": true + }, + "error-ex": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz", + "integrity": "sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==", + "dev": true, + "requires": { + "is-arrayish": "^0.2.1" + } + }, + "es-abstract": { + "version": "1.21.2", + "dev": true, + "requires": { + "array-buffer-byte-length": "^1.0.0", + "available-typed-arrays": "^1.0.5", + "call-bind": "^1.0.2", + "es-set-tostringtag": "^2.0.1", + "es-to-primitive": "^1.2.1", + "function.prototype.name": "^1.1.5", + "get-intrinsic": "^1.2.0", + "get-symbol-description": "^1.0.0", + "globalthis": "^1.0.3", + "gopd": "^1.0.1", + "has": "^1.0.3", + "has-property-descriptors": "^1.0.0", + "has-proto": "^1.0.1", + "has-symbols": "^1.0.3", + "internal-slot": "^1.0.5", + "is-array-buffer": "^3.0.2", + "is-callable": "^1.2.7", + "is-negative-zero": "^2.0.2", + "is-regex": "^1.1.4", + "is-shared-array-buffer": "^1.0.2", + "is-string": "^1.0.7", + "is-typed-array": "^1.1.10", + "is-weakref": "^1.0.2", + "object-inspect": "^1.12.3", + "object-keys": "^1.1.1", + "object.assign": "^4.1.4", + "regexp.prototype.flags": "^1.4.3", + "safe-regex-test": "^1.0.0", + "string.prototype.trim": "^1.2.7", + "string.prototype.trimend": "^1.0.6", + "string.prototype.trimstart": "^1.0.6", + "typed-array-length": "^1.0.4", + "unbox-primitive": "^1.0.2", + "which-typed-array": "^1.1.9" + } + }, + "es-set-tostringtag": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.0.1.tgz", + "integrity": "sha512-g3OMbtlwY3QewlqAiMLI47KywjWZoEytKr8pf6iTC8uJq5bIAH52Z9pnQ8pVL6whrCto53JZDuUIsifGeLorTg==", + "dev": true, + "requires": { + "get-intrinsic": "^1.1.3", + "has": "^1.0.3", + "has-tostringtag": "^1.0.0" + } + }, + "es-shim-unscopables": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/es-shim-unscopables/-/es-shim-unscopables-1.0.0.tgz", + "integrity": "sha512-Jm6GPcCdC30eMLbZ2x8z2WuRwAws3zTBBKuusffYVUrNj/GVSUAZ+xKMaUpfNDR5IbyNA5LJbaecoUVbmUcB1w==", + "dev": true, + "requires": { + "has": "^1.0.3" + } + }, + "es-to-primitive": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.2.1.tgz", + "integrity": "sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==", + "dev": true, + "requires": { + "is-callable": "^1.1.4", + "is-date-object": "^1.0.1", + "is-symbol": "^1.0.2" + } + }, + "escalade": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz", + "integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==", + "dev": true + }, + "escape-string-regexp": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", + "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", + "dev": true + }, + "eslint": { + "version": "8.43.0", + "dev": true, + "requires": { + "@eslint-community/eslint-utils": "^4.2.0", + "@eslint-community/regexpp": "^4.4.0", + "@eslint/eslintrc": "^2.0.3", + "@eslint/js": "8.43.0", + "@humanwhocodes/config-array": "^0.11.10", + "@humanwhocodes/module-importer": "^1.0.1", + "@nodelib/fs.walk": "^1.2.8", + "ajv": "^6.10.0", + "chalk": "^4.0.0", + "cross-spawn": "^7.0.2", + "debug": "^4.3.2", + "doctrine": "^3.0.0", + "escape-string-regexp": "^4.0.0", + "eslint-scope": "^7.2.0", + "eslint-visitor-keys": "^3.4.1", + "espree": "^9.5.2", + "esquery": "^1.4.2", + "esutils": "^2.0.2", + "fast-deep-equal": "^3.1.3", + "file-entry-cache": "^6.0.1", + "find-up": "^5.0.0", + "glob-parent": "^6.0.2", + "globals": "^13.19.0", + "graphemer": "^1.4.0", + "ignore": "^5.2.0", + "import-fresh": "^3.0.0", + "imurmurhash": "^0.1.4", + "is-glob": "^4.0.0", + "is-path-inside": "^3.0.3", + "js-yaml": "^4.1.0", + "json-stable-stringify-without-jsonify": "^1.0.1", + "levn": "^0.4.1", + "lodash.merge": "^4.6.2", + "minimatch": "^3.1.2", + "natural-compare": "^1.4.0", + "optionator": "^0.9.1", + "strip-ansi": "^6.0.1", + "strip-json-comments": "^3.1.0", + "text-table": "^0.2.0" + }, + "dependencies": { + "doctrine": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz", + "integrity": "sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==", + "dev": true, + "requires": { + "esutils": "^2.0.2" + } + }, + "find-up": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", + "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", + "dev": true, + "requires": { + "locate-path": "^6.0.0", + "path-exists": "^4.0.0" + } + }, + "locate-path": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", + "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", + "dev": true, + "requires": { + "p-locate": "^5.0.0" + } + }, + "p-locate": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", + "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", + "dev": true, + "requires": { + "p-limit": "^3.0.2" + } + } + } + }, + "eslint-config-airbnb-base": { + "version": "15.0.0", + "resolved": "https://registry.npmjs.org/eslint-config-airbnb-base/-/eslint-config-airbnb-base-15.0.0.tgz", + "integrity": "sha512-xaX3z4ZZIcFLvh2oUNvcX5oEofXda7giYmuplVxoOg5A7EXJMrUyqRgR+mhDhPK8LZ4PttFOBvCYDbX3sUoUig==", + "dev": true, + "requires": { + "confusing-browser-globals": "^1.0.10", + "object.assign": "^4.1.2", + "object.entries": "^1.1.5", + "semver": "^6.3.0" + } + }, + "eslint-config-airbnb-typescript": { + "version": "17.0.0", + "dev": true, + "requires": { + "eslint-config-airbnb-base": "^15.0.0" + } + }, + "eslint-import-resolver-node": { + "version": "0.3.7", + "dev": true, + "requires": { + "debug": "^3.2.7", + "is-core-module": "^2.11.0", + "resolve": "^1.22.1" + }, + "dependencies": { + "debug": { + "version": "3.2.7", + "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz", + "integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==", + "dev": true, + "requires": { + "ms": "^2.1.1" + } + }, + "ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "dev": true + } + } + }, + "eslint-module-utils": { + "version": "2.8.0", + "dev": true, + "requires": { + "debug": "^3.2.7" + }, + "dependencies": { + "debug": { + "version": "3.2.7", + "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz", + "integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==", + "dev": true, + "requires": { + "ms": "^2.1.1" + } + }, + "ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "dev": true + } + } + }, + "eslint-plugin-import": { + "version": "2.27.5", + "dev": true, + "requires": { + "array-includes": "^3.1.6", + "array.prototype.flat": "^1.3.1", + "array.prototype.flatmap": "^1.3.1", + "debug": "^3.2.7", + "doctrine": "^2.1.0", + "eslint-import-resolver-node": "^0.3.7", + "eslint-module-utils": "^2.7.4", + "has": "^1.0.3", + "is-core-module": "^2.11.0", + "is-glob": "^4.0.3", + "minimatch": "^3.1.2", + "object.values": "^1.1.6", + "resolve": "^1.22.1", + "semver": "^6.3.0", + "tsconfig-paths": "^3.14.1" + }, + "dependencies": { + "debug": { + "version": "3.2.7", + "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz", + "integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==", + "dev": true, + "requires": { + "ms": "^2.1.1" + } + }, + "ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "dev": true + } + } + }, + "eslint-scope": { + "version": "7.2.0", + "dev": true, + "requires": { + "esrecurse": "^4.3.0", + "estraverse": "^5.2.0" + } + }, + "eslint-visitor-keys": { + "version": "3.4.1", + "dev": true + }, + "espree": { + "version": "9.5.2", + "dev": true, + "requires": { + "acorn": "^8.8.0", + "acorn-jsx": "^5.3.2", + "eslint-visitor-keys": "^3.4.1" + } + }, + "esprima": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz", + "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==", + "dev": true + }, + "esquery": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.5.0.tgz", + "integrity": "sha512-YQLXUplAwJgCydQ78IMJywZCceoqk1oH01OERdSAJc/7U2AylwjhSCLDEtqwg811idIS/9fIU5GjG73IgjKMVg==", + "dev": true, + "requires": { + "estraverse": "^5.1.0" + } + }, + "esrecurse": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz", + "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==", + "dev": true, + "requires": { + "estraverse": "^5.2.0" + } + }, + "estraverse": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz", + "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==", + "dev": true + }, + "esutils": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz", + "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==", + "dev": true + }, + "execa": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/execa/-/execa-5.1.1.tgz", + "integrity": "sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==", + "dev": true, + "requires": { + "cross-spawn": "^7.0.3", + "get-stream": "^6.0.0", + "human-signals": "^2.1.0", + "is-stream": "^2.0.0", + "merge-stream": "^2.0.0", + "npm-run-path": "^4.0.1", + "onetime": "^5.1.2", + "signal-exit": "^3.0.3", + "strip-final-newline": "^2.0.0" + } + }, + "exit": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/exit/-/exit-0.1.2.tgz", + "integrity": "sha512-Zk/eNKV2zbjpKzrsQ+n1G6poVbErQxJ0LBOJXaKZ1EViLzH+hrLu9cdXI4zw9dBQJslwBEpbQ2P1oS7nDxs6jQ==", + "dev": true + }, + "expect": { + "version": "29.5.0", + "dev": true, + "requires": { + "@jest/expect-utils": "^29.5.0", + "jest-get-type": "^29.4.3", + "jest-matcher-utils": "^29.5.0", + "jest-message-util": "^29.5.0", + "jest-util": "^29.5.0" + } + }, + "fast-deep-equal": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", + "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", + "dev": true + }, + "fast-glob": { + "version": "3.2.12", + "requires": { + "@nodelib/fs.stat": "^2.0.2", + "@nodelib/fs.walk": "^1.2.3", + "glob-parent": "^5.1.2", + "merge2": "^1.3.0", + "micromatch": "^4.0.4" + }, + "dependencies": { + "glob-parent": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", + "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", + "requires": { + "is-glob": "^4.0.1" + } + } + } + }, + "fast-json-stable-stringify": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz", + "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==", + "dev": true + }, + "fast-levenshtein": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz", + "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==", + "dev": true + }, + "fastq": { + "version": "1.15.0", + "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.15.0.tgz", + "integrity": "sha512-wBrocU2LCXXa+lWBt8RoIRD89Fi8OdABODa/kEnyeyjS5aZO5/GNvI5sEINADqP/h8M29UHTHUb53sUu5Ihqdw==", + "requires": { + "reusify": "^1.0.4" + } + }, + "fb-watchman": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/fb-watchman/-/fb-watchman-2.0.2.tgz", + "integrity": "sha512-p5161BqbuCaSnB8jIbzQHOlpgsPmK5rJVDfDKO91Axs5NC1uu3HRQm6wt9cd9/+GtQQIO53JdGXXoyDpTAsgYA==", + "dev": true, + "requires": { + "bser": "2.1.1" + } + }, + "file-entry-cache": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-6.0.1.tgz", + "integrity": "sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==", + "dev": true, + "requires": { + "flat-cache": "^3.0.4" + } + }, + "fill-range": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz", + "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==", + "requires": { + "to-regex-range": "^5.0.1" + } + }, + "find-up": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz", + "integrity": "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==", + "dev": true, + "requires": { + "locate-path": "^5.0.0", + "path-exists": "^4.0.0" + } + }, + "flat-cache": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-3.0.4.tgz", + "integrity": "sha512-dm9s5Pw7Jc0GvMYbshN6zchCA9RgQlzzEZX3vylR9IqFfS8XciblUXOKfW6SiuJ0e13eDYZoZV5wdrev7P3Nwg==", + "dev": true, + "requires": { + "flatted": "^3.1.0", + "rimraf": "^3.0.2" + } + }, + "flatted": { + "version": "3.2.7", + "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.2.7.tgz", + "integrity": "sha512-5nqDSxl8nn5BSNxyR3n4I6eDmbolI6WT+QqR547RwxQapgjQBmtktdP+HTBb/a/zLsbzERTONyUB5pefh5TtjQ==", + "dev": true + }, + "for-each": { + "version": "0.3.3", + "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.3.tgz", + "integrity": "sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==", + "dev": true, + "requires": { + "is-callable": "^1.1.3" + } + }, + "fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==", + "dev": true + }, + "fsevents": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz", + "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==", + "dev": true, + "optional": true + }, + "function-bind": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz", + "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==", + "dev": true + }, + "function.prototype.name": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/function.prototype.name/-/function.prototype.name-1.1.5.tgz", + "integrity": "sha512-uN7m/BzVKQnCUF/iW8jYea67v++2u7m5UgENbHRtdDVclOUP+FMPlCNdmk0h/ysGyo2tavMJEDqJAkJdRa1vMA==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.3", + "es-abstract": "^1.19.0", + "functions-have-names": "^1.2.2" + } + }, + "functions-have-names": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/functions-have-names/-/functions-have-names-1.2.3.tgz", + "integrity": "sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==", + "dev": true + }, + "gensync": { + "version": "1.0.0-beta.2", + "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz", + "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==", + "dev": true + }, + "get-caller-file": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz", + "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==", + "dev": true + }, + "get-intrinsic": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.1.tgz", + "integrity": "sha512-2DcsyfABl+gVHEfCOaTrWgyt+tb6MSEGmKq+kI5HwLbIYgjgmMcV8KQ41uaKz1xxUcn9tJtgFbQUEVcEbd0FYw==", + "dev": true, + "requires": { + "function-bind": "^1.1.1", + "has": "^1.0.3", + "has-proto": "^1.0.1", + "has-symbols": "^1.0.3" + } + }, + "get-package-type": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/get-package-type/-/get-package-type-0.1.0.tgz", + "integrity": "sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==", + "dev": true + }, + "get-stream": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-6.0.1.tgz", + "integrity": "sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==", + "dev": true + }, + "get-symbol-description": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/get-symbol-description/-/get-symbol-description-1.0.0.tgz", + "integrity": "sha512-2EmdH1YvIQiZpltCNgkuiUnyukzxM/R6NDJX31Ke3BG1Nq5b0S2PhX59UKi9vZpPDQVdqn+1IcaAwnzTT5vCjw==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "get-intrinsic": "^1.1.1" + } + }, + "glob": { + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", + "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", + "dev": true, + "requires": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.1.1", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + } + }, + "glob-parent": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz", + "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==", + "dev": true, + "requires": { + "is-glob": "^4.0.3" + } + }, + "globals": { + "version": "13.20.0", + "dev": true, + "requires": { + "type-fest": "^0.20.2" + } + }, + "globalthis": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/globalthis/-/globalthis-1.0.3.tgz", + "integrity": "sha512-sFdI5LyBiNTHjRd7cGPWapiHWMOXKyuBNX/cWJ3NfzrZQVa8GI/8cofCl74AOVqq9W5kNmguTIzJ/1s2gyI9wA==", + "dev": true, + "requires": { + "define-properties": "^1.1.3" + } + }, + "globby": { + "version": "11.1.0", + "resolved": "https://registry.npmjs.org/globby/-/globby-11.1.0.tgz", + "integrity": "sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==", + "dev": true, + "requires": { + "array-union": "^2.1.0", + "dir-glob": "^3.0.1", + "fast-glob": "^3.2.9", + "ignore": "^5.2.0", + "merge2": "^1.4.1", + "slash": "^3.0.0" + } + }, + "gopd": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.0.1.tgz", + "integrity": "sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==", + "dev": true, + "requires": { + "get-intrinsic": "^1.1.3" + } + }, + "graceful-fs": { + "version": "4.2.11", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz", + "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==", + "dev": true + }, + "grapheme-splitter": { + "version": "1.0.4", + "dev": true + }, + "graphemer": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/graphemer/-/graphemer-1.4.0.tgz", + "integrity": "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==", + "dev": true + }, + "has": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz", + "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==", + "dev": true, + "requires": { + "function-bind": "^1.1.1" + } + }, + "has-bigints": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/has-bigints/-/has-bigints-1.0.2.tgz", + "integrity": "sha512-tSvCKtBr9lkF0Ex0aQiP9N+OpV4zi2r/Nee5VkRDbaqv35RLYMzbwQfFSZZH0kR+Rd6302UJZ2p/bJCEoR3VoQ==", + "dev": true + }, + "has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true + }, + "has-property-descriptors": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.0.tgz", + "integrity": "sha512-62DVLZGoiEBDHQyqG4w9xCuZ7eJEwNmJRWw2VY84Oedb7WFcA27fiEVe8oUQx9hAUJ4ekurquucTGwsyO1XGdQ==", + "dev": true, + "requires": { + "get-intrinsic": "^1.1.1" + } + }, + "has-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.0.1.tgz", + "integrity": "sha512-7qE+iP+O+bgF9clE5+UoBFzE65mlBiVj3tKCrlNQ0Ogwm0BjpT/gK4SlLYDMybDh5I3TCTKnPPa0oMG7JDYrhg==", + "dev": true + }, + "has-symbols": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz", + "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==", + "dev": true + }, + "has-tostringtag": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.0.tgz", + "integrity": "sha512-kFjcSNhnlGV1kyoGk7OXKSawH5JOb/LzUc5w9B02hOTO0dfFRjbHQKvg1d6cf3HbeUmtU9VbbV3qzZ2Teh97WQ==", + "dev": true, + "requires": { + "has-symbols": "^1.0.2" + } + }, + "header-case": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/header-case/-/header-case-2.0.4.tgz", + "integrity": "sha512-H/vuk5TEEVZwrR0lp2zed9OCo1uAILMlx0JEMgC26rzyJJ3N1v6XkwHHXJQdR2doSjcGPM6OKPYoJgf0plJ11Q==", + "dev": true, + "requires": { + "capital-case": "^1.0.4", + "tslib": "^2.0.3" + } + }, + "hi-base32": { + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/hi-base32/-/hi-base32-0.5.1.tgz", + "integrity": "sha512-EmBBpvdYh/4XxsnUybsPag6VikPYnN30td+vQk+GI3qpahVEG9+gTkG0aXVxTjBqQ5T6ijbWIu77O+C5WFWsnA==" + }, + "html-escaper": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz", + "integrity": "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==", + "dev": true + }, + "human-signals": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-2.1.0.tgz", + "integrity": "sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==", + "dev": true + }, + "ieee754": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz", + "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==" + }, + "ignore": { + "version": "5.2.4", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.2.4.tgz", + "integrity": "sha512-MAb38BcSbH0eHNBxn7ql2NH/kX33OkB3lZ1BNdh7ENeRChHTYsTvWrMubiIAMNS2llXEEgZ1MUOBtXChP3kaFQ==", + "dev": true + }, + "import-fresh": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.0.tgz", + "integrity": "sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==", + "dev": true, + "requires": { + "parent-module": "^1.0.0", + "resolve-from": "^4.0.0" + }, + "dependencies": { + "resolve-from": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz", + "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==", + "dev": true + } + } + }, + "import-local": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/import-local/-/import-local-3.1.0.tgz", + "integrity": "sha512-ASB07uLtnDs1o6EHjKpX34BKYDSqnFerfTOJL2HvMqF70LnxpjkzDB8J44oT9pu4AMPkQwf8jl6szgvNd2tRIg==", + "dev": true, + "requires": { + "pkg-dir": "^4.2.0", + "resolve-cwd": "^3.0.0" + } + }, + "imurmurhash": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", + "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==", + "dev": true + }, + "inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==", + "dev": true, + "requires": { + "once": "^1.3.0", + "wrappy": "1" + } + }, + "inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", + "dev": true + }, + "internal-slot": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.0.5.tgz", + "integrity": "sha512-Y+R5hJrzs52QCG2laLn4udYVnxsfny9CpOhNhUvk/SSSVyF6T27FzRbF0sroPidSu3X8oEAkOn2K804mjpt6UQ==", + "dev": true, + "requires": { + "get-intrinsic": "^1.2.0", + "has": "^1.0.3", + "side-channel": "^1.0.4" + } + }, + "is-array-buffer": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/is-array-buffer/-/is-array-buffer-3.0.2.tgz", + "integrity": "sha512-y+FyyR/w8vfIRq4eQcM1EYgSTnmHXPqaF+IgzgraytCFq5Xh8lllDVmAZolPJiZttZLeFSINPYMaEJ7/vWUa1w==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "get-intrinsic": "^1.2.0", + "is-typed-array": "^1.1.10" + } + }, + "is-arrayish": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz", + "integrity": "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==", + "dev": true + }, + "is-bigint": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/is-bigint/-/is-bigint-1.0.4.tgz", + "integrity": "sha512-zB9CruMamjym81i2JZ3UMn54PKGsQzsJeo6xvN3HJJ4CAsQNB6iRutp2To77OfCNuoxspsIhzaPoO1zyCEhFOg==", + "dev": true, + "requires": { + "has-bigints": "^1.0.1" + } + }, + "is-boolean-object": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.1.2.tgz", + "integrity": "sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "has-tostringtag": "^1.0.0" + } + }, + "is-callable": { + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz", + "integrity": "sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==", + "dev": true + }, + "is-core-module": { + "version": "2.12.1", + "dev": true, + "requires": { + "has": "^1.0.3" + } + }, + "is-date-object": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.5.tgz", + "integrity": "sha512-9YQaSxsAiSwcvS33MBk3wTCVnWK+HhF8VZR2jRxehM16QcVOdHqPn4VPHmRK4lSr38n9JriurInLcP90xsYNfQ==", + "dev": true, + "requires": { + "has-tostringtag": "^1.0.0" + } + }, + "is-extglob": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", + "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==" + }, + "is-fullwidth-code-point": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", + "dev": true + }, + "is-generator-fn": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-generator-fn/-/is-generator-fn-2.1.0.tgz", + "integrity": "sha512-cTIB4yPYL/Grw0EaSzASzg6bBy9gqCofvWN8okThAYIxKJZC+udlRAmGbM0XLeniEJSs8uEgHPGuHSe1XsOLSQ==", + "dev": true + }, + "is-glob": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", + "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", + "requires": { + "is-extglob": "^2.1.1" + } + }, + "is-negative-zero": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/is-negative-zero/-/is-negative-zero-2.0.2.tgz", + "integrity": "sha512-dqJvarLawXsFbNDeJW7zAz8ItJ9cd28YufuuFzh0G8pNHjJMnY08Dv7sYX2uF5UpQOwieAeOExEYAWWfu7ZZUA==", + "dev": true + }, + "is-number": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", + "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==" + }, + "is-number-object": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/is-number-object/-/is-number-object-1.0.7.tgz", + "integrity": "sha512-k1U0IRzLMo7ZlYIfzRu23Oh6MiIFasgpb9X76eqfFZAqwH44UI4KTBvBYIZ1dSL9ZzChTB9ShHfLkR4pdW5krQ==", + "dev": true, + "requires": { + "has-tostringtag": "^1.0.0" + } + }, + "is-path-inside": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.3.tgz", + "integrity": "sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==", + "dev": true + }, + "is-regex": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.1.4.tgz", + "integrity": "sha512-kvRdxDsxZjhzUX07ZnLydzS1TU/TJlTUHHY4YLL87e37oUA49DfkLqgy+VjFocowy29cKvcSiu+kIv728jTTVg==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "has-tostringtag": "^1.0.0" + } + }, + "is-shared-array-buffer": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-shared-array-buffer/-/is-shared-array-buffer-1.0.2.tgz", + "integrity": "sha512-sqN2UDu1/0y6uvXyStCOzyhAjCSlHceFoMKJW8W9EU9cvic/QdsZ0kEU93HEy3IUEFZIiH/3w+AH/UQbPHNdhA==", + "dev": true, + "requires": { + "call-bind": "^1.0.2" + } + }, + "is-stream": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz", + "integrity": "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==", + "dev": true + }, + "is-string": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/is-string/-/is-string-1.0.7.tgz", + "integrity": "sha512-tE2UXzivje6ofPW7l23cjDOMa09gb7xlAqG6jG5ej6uPV32TlWP3NKPigtaGeHNu9fohccRYvIiZMfOOnOYUtg==", + "dev": true, + "requires": { + "has-tostringtag": "^1.0.0" + } + }, + "is-symbol": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.4.tgz", + "integrity": "sha512-C/CPBqKWnvdcxqIARxyOh4v1UUEOCHpgDa0WYgpKDFMszcrPcffg5uhwSgPCLD2WWxmq6isisz87tzT01tuGhg==", + "dev": true, + "requires": { + "has-symbols": "^1.0.2" + } + }, + "is-typed-array": { + "version": "1.1.10", + "dev": true, + "requires": { + "available-typed-arrays": "^1.0.5", + "call-bind": "^1.0.2", + "for-each": "^0.3.3", + "gopd": "^1.0.1", + "has-tostringtag": "^1.0.0" + } + }, + "is-weakref": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-weakref/-/is-weakref-1.0.2.tgz", + "integrity": "sha512-qctsuLZmIQ0+vSSMfoVvyFe2+GSEvnmZ2ezTup1SBse9+twCCeial6EEi3Nc2KFcf6+qz2FBPnjXsk8xhKSaPQ==", + "dev": true, + "requires": { + "call-bind": "^1.0.2" + } + }, + "isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", + "dev": true + }, + "istanbul-lib-coverage": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.0.tgz", + "integrity": "sha512-eOeJ5BHCmHYvQK7xt9GkdHuzuCGS1Y6g9Gvnx3Ym33fz/HpLRYxiS0wHNr+m/MBC8B647Xt608vCDEvhl9c6Mw==", + "dev": true + }, + "istanbul-lib-instrument": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/istanbul-lib-instrument/-/istanbul-lib-instrument-5.2.1.tgz", + "integrity": "sha512-pzqtp31nLv/XFOzXGuvhCb8qhjmTVo5vjVk19XE4CRlSWz0KoeJ3bw9XsA7nOp9YBf4qHjwBxkDzKcME/J29Yg==", + "dev": true, + "requires": { + "@babel/core": "^7.12.3", + "@babel/parser": "^7.14.7", + "@istanbuljs/schema": "^0.1.2", + "istanbul-lib-coverage": "^3.2.0", + "semver": "^6.3.0" + } + }, + "istanbul-lib-report": { + "version": "3.0.0", + "dev": true, + "requires": { + "istanbul-lib-coverage": "^3.0.0", + "make-dir": "^3.0.0", + "supports-color": "^7.1.0" + } + }, + "istanbul-lib-source-maps": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/istanbul-lib-source-maps/-/istanbul-lib-source-maps-4.0.1.tgz", + "integrity": "sha512-n3s8EwkdFIJCG3BPKBYvskgXGoy88ARzvegkitk60NxRdwltLOTaH7CUiMRXvwYorl0Q712iEjcWB+fK/MrWVw==", + "dev": true, + "requires": { + "debug": "^4.1.1", + "istanbul-lib-coverage": "^3.0.0", + "source-map": "^0.6.1" + } + }, + "istanbul-reports": { + "version": "3.1.5", + "dev": true, + "requires": { + "html-escaper": "^2.0.0", + "istanbul-lib-report": "^3.0.0" + } + }, + "jest": { + "version": "29.5.0", + "dev": true, + "requires": { + "@jest/core": "^29.5.0", + "@jest/types": "^29.5.0", + "import-local": "^3.0.2", + "jest-cli": "^29.5.0" + } + }, + "jest-changed-files": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-changed-files/-/jest-changed-files-29.5.0.tgz", + "integrity": "sha512-IFG34IUMUaNBIxjQXF/iu7g6EcdMrGRRxaUSw92I/2g2YC6vCdTltl4nHvt7Ci5nSJwXIkCu8Ka1DKF+X7Z1Ag==", + "dev": true, + "requires": { + "execa": "^5.0.0", + "p-limit": "^3.1.0" + } + }, + "jest-circus": { + "version": "29.5.0", + "dev": true, + "requires": { + "@jest/environment": "^29.5.0", + "@jest/expect": "^29.5.0", + "@jest/test-result": "^29.5.0", + "@jest/types": "^29.5.0", + "@types/node": "*", + "chalk": "^4.0.0", + "co": "^4.6.0", + "dedent": "^0.7.0", + "is-generator-fn": "^2.0.0", + "jest-each": "^29.5.0", + "jest-matcher-utils": "^29.5.0", + "jest-message-util": "^29.5.0", + "jest-runtime": "^29.5.0", + "jest-snapshot": "^29.5.0", + "jest-util": "^29.5.0", + "p-limit": "^3.1.0", + "pretty-format": "^29.5.0", + "pure-rand": "^6.0.0", + "slash": "^3.0.0", + "stack-utils": "^2.0.3" + } + }, + "jest-cli": { + "version": "29.5.0", + "dev": true, + "requires": { + "@jest/core": "^29.5.0", + "@jest/test-result": "^29.5.0", + "@jest/types": "^29.5.0", + "chalk": "^4.0.0", + "exit": "^0.1.2", + "graceful-fs": "^4.2.9", + "import-local": "^3.0.2", + "jest-config": "^29.5.0", + "jest-util": "^29.5.0", + "jest-validate": "^29.5.0", + "prompts": "^2.0.1", + "yargs": "^17.3.1" + } + }, + "jest-config": { + "version": "29.5.0", + "dev": true, + "requires": { + "@babel/core": "^7.11.6", + "@jest/test-sequencer": "^29.5.0", + "@jest/types": "^29.5.0", + "babel-jest": "^29.5.0", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "deepmerge": "^4.2.2", + "glob": "^7.1.3", + "graceful-fs": "^4.2.9", + "jest-circus": "^29.5.0", + "jest-environment-node": "^29.5.0", + "jest-get-type": "^29.4.3", + "jest-regex-util": "^29.4.3", + "jest-resolve": "^29.5.0", + "jest-runner": "^29.5.0", + "jest-util": "^29.5.0", + "jest-validate": "^29.5.0", + "micromatch": "^4.0.4", + "parse-json": "^5.2.0", + "pretty-format": "^29.5.0", + "slash": "^3.0.0", + "strip-json-comments": "^3.1.1" + } + }, + "jest-diff": { + "version": "29.5.0", + "dev": true, + "requires": { + "chalk": "^4.0.0", + "diff-sequences": "^29.4.3", + "jest-get-type": "^29.4.3", + "pretty-format": "^29.5.0" + } + }, + "jest-docblock": { + "version": "29.4.3", + "resolved": "https://registry.npmjs.org/jest-docblock/-/jest-docblock-29.4.3.tgz", + "integrity": "sha512-fzdTftThczeSD9nZ3fzA/4KkHtnmllawWrXO69vtI+L9WjEIuXWs4AmyME7lN5hU7dB0sHhuPfcKofRsUb/2Fg==", + "dev": true, + "requires": { + "detect-newline": "^3.0.0" + } + }, + "jest-each": { + "version": "29.5.0", + "dev": true, + "requires": { + "@jest/types": "^29.5.0", + "chalk": "^4.0.0", + "jest-get-type": "^29.4.3", + "jest-util": "^29.5.0", + "pretty-format": "^29.5.0" + } + }, + "jest-environment-node": { + "version": "29.5.0", + "dev": true, + "requires": { + "@jest/environment": "^29.5.0", + "@jest/fake-timers": "^29.5.0", + "@jest/types": "^29.5.0", + "@types/node": "*", + "jest-mock": "^29.5.0", + "jest-util": "^29.5.0" + } + }, + "jest-get-type": { + "version": "29.4.3", + "resolved": "https://registry.npmjs.org/jest-get-type/-/jest-get-type-29.4.3.tgz", + "integrity": "sha512-J5Xez4nRRMjk8emnTpWrlkyb9pfRQQanDrvWHhsR1+VUfbwxi30eVcZFlcdGInRibU4G5LwHXpI7IRHU0CY+gg==", + "dev": true + }, + "jest-haste-map": { + "version": "29.5.0", + "dev": true, + "requires": { + "@jest/types": "^29.5.0", + "@types/graceful-fs": "^4.1.3", + "@types/node": "*", + "anymatch": "^3.0.3", + "fb-watchman": "^2.0.0", + "fsevents": "^2.3.2", + "graceful-fs": "^4.2.9", + "jest-regex-util": "^29.4.3", + "jest-util": "^29.5.0", + "jest-worker": "^29.5.0", + "micromatch": "^4.0.4", + "walker": "^1.0.8" + } + }, + "jest-leak-detector": { + "version": "29.5.0", + "dev": true, + "requires": { + "jest-get-type": "^29.4.3", + "pretty-format": "^29.5.0" + } + }, + "jest-matcher-utils": { + "version": "29.5.0", + "dev": true, + "requires": { + "chalk": "^4.0.0", + "jest-diff": "^29.5.0", + "jest-get-type": "^29.4.3", + "pretty-format": "^29.5.0" + } + }, + "jest-message-util": { + "version": "29.5.0", + "dev": true, + "requires": { + "@babel/code-frame": "^7.12.13", + "@jest/types": "^29.5.0", + "@types/stack-utils": "^2.0.0", + "chalk": "^4.0.0", + "graceful-fs": "^4.2.9", + "micromatch": "^4.0.4", + "pretty-format": "^29.5.0", + "slash": "^3.0.0", + "stack-utils": "^2.0.3" + } + }, + "jest-mock": { + "version": "29.5.0", + "dev": true, + "requires": { + "@jest/types": "^29.5.0", + "@types/node": "*", + "jest-util": "^29.5.0" + } + }, + "jest-pnp-resolver": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/jest-pnp-resolver/-/jest-pnp-resolver-1.2.3.tgz", + "integrity": "sha512-+3NpwQEnRoIBtx4fyhblQDPgJI0H1IEIkX7ShLUjPGA7TtUTvI1oiKi3SR4oBR0hQhQR80l4WAe5RrXBwWMA8w==", + "dev": true, + "requires": {} + }, + "jest-regex-util": { + "version": "29.4.3", + "resolved": "https://registry.npmjs.org/jest-regex-util/-/jest-regex-util-29.4.3.tgz", + "integrity": "sha512-O4FglZaMmWXbGHSQInfXewIsd1LMn9p3ZXB/6r4FOkyhX2/iP/soMG98jGvk/A3HAN78+5VWcBGO0BJAPRh4kg==", + "dev": true + }, + "jest-resolve": { + "version": "29.5.0", + "dev": true, + "requires": { + "chalk": "^4.0.0", + "graceful-fs": "^4.2.9", + "jest-haste-map": "^29.5.0", + "jest-pnp-resolver": "^1.2.2", + "jest-util": "^29.5.0", + "jest-validate": "^29.5.0", + "resolve": "^1.20.0", + "resolve.exports": "^2.0.0", + "slash": "^3.0.0" + } + }, + "jest-resolve-dependencies": { + "version": "29.5.0", + "dev": true, + "requires": { + "jest-regex-util": "^29.4.3", + "jest-snapshot": "^29.5.0" + } + }, + "jest-runner": { + "version": "29.5.0", + "dev": true, + "requires": { + "@jest/console": "^29.5.0", + "@jest/environment": "^29.5.0", + "@jest/test-result": "^29.5.0", + "@jest/transform": "^29.5.0", + "@jest/types": "^29.5.0", + "@types/node": "*", + "chalk": "^4.0.0", + "emittery": "^0.13.1", + "graceful-fs": "^4.2.9", + "jest-docblock": "^29.4.3", + "jest-environment-node": "^29.5.0", + "jest-haste-map": "^29.5.0", + "jest-leak-detector": "^29.5.0", + "jest-message-util": "^29.5.0", + "jest-resolve": "^29.5.0", + "jest-runtime": "^29.5.0", + "jest-util": "^29.5.0", + "jest-watcher": "^29.5.0", + "jest-worker": "^29.5.0", + "p-limit": "^3.1.0", + "source-map-support": "0.5.13" + } + }, + "jest-runtime": { + "version": "29.5.0", + "dev": true, + "requires": { + "@jest/environment": "^29.5.0", + "@jest/fake-timers": "^29.5.0", + "@jest/globals": "^29.5.0", + "@jest/source-map": "^29.4.3", + "@jest/test-result": "^29.5.0", + "@jest/transform": "^29.5.0", + "@jest/types": "^29.5.0", + "@types/node": "*", + "chalk": "^4.0.0", + "cjs-module-lexer": "^1.0.0", + "collect-v8-coverage": "^1.0.0", + "glob": "^7.1.3", + "graceful-fs": "^4.2.9", + "jest-haste-map": "^29.5.0", + "jest-message-util": "^29.5.0", + "jest-mock": "^29.5.0", + "jest-regex-util": "^29.4.3", + "jest-resolve": "^29.5.0", + "jest-snapshot": "^29.5.0", + "jest-util": "^29.5.0", + "slash": "^3.0.0", + "strip-bom": "^4.0.0" + }, + "dependencies": { + "strip-bom": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-4.0.0.tgz", + "integrity": "sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w==", + "dev": true + } + } + }, + "jest-snapshot": { + "version": "29.5.0", + "dev": true, + "requires": { + "@babel/core": "^7.11.6", + "@babel/generator": "^7.7.2", + "@babel/plugin-syntax-jsx": "^7.7.2", + "@babel/plugin-syntax-typescript": "^7.7.2", + "@babel/traverse": "^7.7.2", + "@babel/types": "^7.3.3", + "@jest/expect-utils": "^29.5.0", + "@jest/transform": "^29.5.0", + "@jest/types": "^29.5.0", + "@types/babel__traverse": "^7.0.6", + "@types/prettier": "^2.1.5", + "babel-preset-current-node-syntax": "^1.0.0", + "chalk": "^4.0.0", + "expect": "^29.5.0", + "graceful-fs": "^4.2.9", + "jest-diff": "^29.5.0", + "jest-get-type": "^29.4.3", + "jest-matcher-utils": "^29.5.0", + "jest-message-util": "^29.5.0", + "jest-util": "^29.5.0", + "natural-compare": "^1.4.0", + "pretty-format": "^29.5.0", + "semver": "^7.3.5" + }, + "dependencies": { + "semver": { + "version": "7.5.2", + "dev": true, + "requires": { + "lru-cache": "^6.0.0" + } + } + } + }, + "jest-util": { + "version": "29.5.0", + "dev": true, + "requires": { + "@jest/types": "^29.5.0", + "@types/node": "*", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "graceful-fs": "^4.2.9", + "picomatch": "^2.2.3" + } + }, + "jest-validate": { + "version": "29.5.0", + "dev": true, + "requires": { + "@jest/types": "^29.5.0", + "camelcase": "^6.2.0", + "chalk": "^4.0.0", + "jest-get-type": "^29.4.3", + "leven": "^3.1.0", + "pretty-format": "^29.5.0" + } + }, + "jest-watcher": { + "version": "29.5.0", + "dev": true, + "requires": { + "@jest/test-result": "^29.5.0", + "@jest/types": "^29.5.0", + "@types/node": "*", + "ansi-escapes": "^4.2.1", + "chalk": "^4.0.0", + "emittery": "^0.13.1", + "jest-util": "^29.5.0", + "string-length": "^4.0.1" + } + }, + "jest-worker": { + "version": "29.5.0", + "dev": true, + "requires": { + "@types/node": "*", + "jest-util": "^29.5.0", + "merge-stream": "^2.0.0", + "supports-color": "^8.0.0" + }, + "dependencies": { + "supports-color": { + "version": "8.1.1", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz", + "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==", + "dev": true, + "requires": { + "has-flag": "^4.0.0" + } + } + } + }, + "js-sha256": { + "version": "0.9.0", + "resolved": "https://registry.npmjs.org/js-sha256/-/js-sha256-0.9.0.tgz", + "integrity": "sha512-sga3MHh9sgQN2+pJ9VYZ+1LPwXOxuBJBA5nrR5/ofPfuiJBE2hnjsaN8se8JznOmGLN2p49Pe5U/ttafcs/apA==" + }, + "js-sha3": { + "version": "0.8.0", + "resolved": "https://registry.npmjs.org/js-sha3/-/js-sha3-0.8.0.tgz", + "integrity": "sha512-gF1cRrHhIzNfToc802P800N8PpXS+evLLXfsVpowqmAFR9uwbi89WvXg2QspOmXL8QL86J4T1EpFu+yUkwJY3Q==" + }, + "js-sha512": { + "version": "0.8.0", + "resolved": "https://registry.npmjs.org/js-sha512/-/js-sha512-0.8.0.tgz", + "integrity": "sha512-PWsmefG6Jkodqt+ePTvBZCSMFgN7Clckjd0O7su3I0+BW2QWUTJNzjktHsztGLhncP2h8mcF9V9Y2Ha59pAViQ==" + }, + "js-tokens": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", + "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==", + "dev": true + }, + "js-yaml": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz", + "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==", + "dev": true, + "requires": { + "argparse": "^2.0.1" + } + }, + "jsesc": { + "version": "2.5.2", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-2.5.2.tgz", + "integrity": "sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==", + "dev": true + }, + "json-bigint": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/json-bigint/-/json-bigint-1.0.0.tgz", + "integrity": "sha512-SiPv/8VpZuWbvLSMtTDU8hEfrZWg/mH/nV/b4o0CYbSxu1UIQPLdwKOCIyLQX+VIPO5vrLX3i8qtqFyhdPSUSQ==", + "requires": { + "bignumber.js": "^9.0.0" + } + }, + "json-parse-even-better-errors": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz", + "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==", + "dev": true + }, + "json-schema-traverse": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", + "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==", + "dev": true + }, + "json-stable-stringify-without-jsonify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz", + "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==", + "dev": true + }, + "json5": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz", + "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==", + "dev": true + }, + "jsonschema": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/jsonschema/-/jsonschema-1.4.1.tgz", + "integrity": "sha512-S6cATIPVv1z0IlxdN+zUk5EPjkGCdnhN4wVSBlvoUO1tOLJootbo9CquNJmbIh4yikWHiUedhRYrNPn1arpEmQ==", + "dev": true + }, + "kleur": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/kleur/-/kleur-3.0.3.tgz", + "integrity": "sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==", + "dev": true + }, + "leven": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/leven/-/leven-3.1.0.tgz", + "integrity": "sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==", + "dev": true + }, + "levn": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz", + "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==", + "dev": true, + "requires": { + "prelude-ls": "^1.2.1", + "type-check": "~0.4.0" + } + }, + "lines-and-columns": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz", + "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==", + "dev": true + }, + "locate-path": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz", + "integrity": "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==", + "dev": true, + "requires": { + "p-locate": "^4.1.0" + } + }, + "lodash.memoize": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/lodash.memoize/-/lodash.memoize-4.1.2.tgz", + "integrity": "sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag==", + "dev": true + }, + "lodash.merge": { + "version": "4.6.2", + "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz", + "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==", + "dev": true + }, + "lower-case": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/lower-case/-/lower-case-2.0.2.tgz", + "integrity": "sha512-7fm3l3NAF9WfN6W3JOmf5drwpVqX78JtoGJ3A6W0a6ZnldM41w2fV5D490psKFTpMds8TJse/eHLFFsNHHjHgg==", + "dev": true, + "requires": { + "tslib": "^2.0.3" + } + }, + "lru-cache": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz", + "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==", + "dev": true, + "requires": { + "yallist": "^4.0.0" + } + }, + "make-dir": { + "version": "3.1.0", + "dev": true, + "requires": { + "semver": "^6.0.0" + } + }, + "make-error": { + "version": "1.3.6", + "resolved": "https://registry.npmjs.org/make-error/-/make-error-1.3.6.tgz", + "integrity": "sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==", + "dev": true + }, + "makeerror": { + "version": "1.0.12", + "resolved": "https://registry.npmjs.org/makeerror/-/makeerror-1.0.12.tgz", + "integrity": "sha512-JmqCvUhmt43madlpFzG4BQzG2Z3m6tvQDNKdClZnO3VbIudJYmxsT0FNJMeiB2+JTSlTQTSbU8QdesVmwJcmLg==", + "dev": true, + "requires": { + "tmpl": "1.0.5" + } + }, + "merge-stream": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz", + "integrity": "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==", + "dev": true + }, + "merge2": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz", + "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==" + }, + "micromatch": { + "version": "4.0.5", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.5.tgz", + "integrity": "sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==", + "requires": { + "braces": "^3.0.2", + "picomatch": "^2.3.1" + } + }, + "mimic-fn": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz", + "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==", + "dev": true + }, + "minimatch": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", + "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "dev": true, + "requires": { + "brace-expansion": "^1.1.7" + } + }, + "minimist": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz", + "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==", + "dev": true + }, + "mkdirp": { + "version": "2.1.6", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-2.1.6.tgz", + "integrity": "sha512-+hEnITedc8LAtIP9u3HJDFIdcLV2vXP33sqLLIzkv1Db1zO/1OxbvYf0Y1OC/S/Qo5dxHXepofhmxL02PsKe+A==" + }, + "ms": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", + "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==", + "dev": true + }, + "natural-compare": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz", + "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==", + "dev": true + }, + "natural-compare-lite": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/natural-compare-lite/-/natural-compare-lite-1.4.0.tgz", + "integrity": "sha512-Tj+HTDSJJKaZnfiuw+iaF9skdPpTo2GtEly5JHnWV/hfv2Qj/9RKsGISQtLh2ox3l5EAGw487hnBee0sIJ6v2g==", + "dev": true + }, + "no-case": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/no-case/-/no-case-3.0.4.tgz", + "integrity": "sha512-fgAN3jGAh+RoxUGZHTSOLJIqUc2wmoBwGR4tbpNAKmmovFoWq0OdRkb0VkldReO2a2iBT/OEulG9XSUc10r3zg==", + "dev": true, + "requires": { + "lower-case": "^2.0.2", + "tslib": "^2.0.3" + } + }, + "node-fetch": { + "version": "2.7.0", + "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz", + "integrity": "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==", + "requires": { + "whatwg-url": "^5.0.0" + } + }, + "node-int64": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/node-int64/-/node-int64-0.4.0.tgz", + "integrity": "sha512-O5lz91xSOeoXP6DulyHfllpq+Eg00MWitZIbtPfoSEvqIHdl5gfcY6hYzDWnj0qD5tz52PI08u9qUvSVeUBeHw==", + "dev": true + }, + "node-releases": { + "version": "2.0.12", + "dev": true + }, + "normalize-path": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz", + "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==", + "dev": true + }, + "npm-run-path": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-4.0.1.tgz", + "integrity": "sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==", + "dev": true, + "requires": { + "path-key": "^3.0.0" + } + }, + "object-inspect": { + "version": "1.12.3", + "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.12.3.tgz", + "integrity": "sha512-geUvdk7c+eizMNUDkRpW1wJwgfOiOeHbxBR/hLXK1aT6zmVSO0jsQcs7fj6MGw89jC/cjGfLcNOrtMYtGqm81g==", + "dev": true + }, + "object-keys": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz", + "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==", + "dev": true + }, + "object.assign": { + "version": "4.1.4", + "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.4.tgz", + "integrity": "sha512-1mxKf0e58bvyjSCtKYY4sRe9itRk3PJpquJOjeIkz885CczcI4IvJJDLPS72oowuSh+pBxUFROpX+TU++hxhZQ==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "has-symbols": "^1.0.3", + "object-keys": "^1.1.1" + } + }, + "object.entries": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/object.entries/-/object.entries-1.1.6.tgz", + "integrity": "sha512-leTPzo4Zvg3pmbQ3rDK69Rl8GQvIqMWubrkxONG9/ojtFE2rD9fjMKfSI5BxW3osRH1m6VdzmqK8oAY9aT4x5w==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + } + }, + "object.values": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/object.values/-/object.values-1.1.6.tgz", + "integrity": "sha512-FVVTkD1vENCsAcwNs9k6jea2uHC/X0+JcjG8YA60FN5CMaJmG95wT9jek/xX9nornqGRrBkKtzuAu2wuHpKqvw==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + } + }, + "once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==", + "dev": true, + "requires": { + "wrappy": "1" + } + }, + "onetime": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz", + "integrity": "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==", + "dev": true, + "requires": { + "mimic-fn": "^2.1.0" + } + }, + "optionator": { + "version": "0.9.1", + "dev": true, + "requires": { + "deep-is": "^0.1.3", + "fast-levenshtein": "^2.0.6", + "levn": "^0.4.1", + "prelude-ls": "^1.2.1", + "type-check": "^0.4.0", + "word-wrap": "^1.2.3" + } + }, + "p-limit": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + "dev": true, + "requires": { + "yocto-queue": "^0.1.0" + } + }, + "p-locate": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz", + "integrity": "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==", + "dev": true, + "requires": { + "p-limit": "^2.2.0" + }, + "dependencies": { + "p-limit": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz", + "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==", + "dev": true, + "requires": { + "p-try": "^2.0.0" + } + } + } + }, + "p-try": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz", + "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==", + "dev": true + }, + "param-case": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/param-case/-/param-case-3.0.4.tgz", + "integrity": "sha512-RXlj7zCYokReqWpOPH9oYivUzLYZ5vAPIfEmCTNViosC78F8F0H9y7T7gG2M39ymgutxF5gcFEsyZQSph9Bp3A==", + "dev": true, + "requires": { + "dot-case": "^3.0.4", + "tslib": "^2.0.3" + } + }, + "parent-module": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz", + "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==", + "dev": true, + "requires": { + "callsites": "^3.0.0" + } + }, + "parse-json": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-5.2.0.tgz", + "integrity": "sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==", + "dev": true, + "requires": { + "@babel/code-frame": "^7.0.0", + "error-ex": "^1.3.1", + "json-parse-even-better-errors": "^2.3.0", + "lines-and-columns": "^1.1.6" + } + }, + "pascal-case": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/pascal-case/-/pascal-case-3.1.2.tgz", + "integrity": "sha512-uWlGT3YSnK9x3BQJaOdcZwrnV6hPpd8jFH1/ucpiLRPh/2zCVJKS19E4GvYHvaCcACn3foXZ0cLB9Wrx1KGe5g==", + "dev": true, + "requires": { + "no-case": "^3.0.4", + "tslib": "^2.0.3" + } + }, + "path-browserify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-browserify/-/path-browserify-1.0.1.tgz", + "integrity": "sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g==" + }, + "path-case": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/path-case/-/path-case-3.0.4.tgz", + "integrity": "sha512-qO4qCFjXqVTrcbPt/hQfhTQ+VhFsqNKOPtytgNKkKxSoEp3XPUQ8ObFuePylOIok5gjn69ry8XiULxCwot3Wfg==", + "dev": true, + "requires": { + "dot-case": "^3.0.4", + "tslib": "^2.0.3" + } + }, + "path-exists": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", + "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", + "dev": true + }, + "path-is-absolute": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", + "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==", + "dev": true + }, + "path-key": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", + "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", + "dev": true + }, + "path-parse": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", + "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", + "dev": true + }, + "path-type": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz", + "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==", + "dev": true + }, + "picocolors": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.0.0.tgz", + "integrity": "sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==", + "dev": true + }, + "picomatch": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", + "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==" + }, + "pirates": { + "version": "4.0.6", + "resolved": "https://registry.npmjs.org/pirates/-/pirates-4.0.6.tgz", + "integrity": "sha512-saLsH7WeYYPiD25LDuLRRY/i+6HaPYr6G1OUlN39otzkSTxKnubR9RTxS3/Kk50s1g2JTgFwWQDQyplC5/SHZg==", + "dev": true + }, + "pkg-dir": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/pkg-dir/-/pkg-dir-4.2.0.tgz", + "integrity": "sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==", + "dev": true, + "requires": { + "find-up": "^4.0.0" + } + }, + "prelude-ls": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz", + "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==", + "dev": true + }, + "pretty-format": { + "version": "29.5.0", + "dev": true, + "requires": { + "@jest/schemas": "^29.4.3", + "ansi-styles": "^5.0.0", + "react-is": "^18.0.0" + }, + "dependencies": { + "ansi-styles": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz", + "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==", + "dev": true + } + } + }, + "prompts": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/prompts/-/prompts-2.4.2.tgz", + "integrity": "sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q==", + "dev": true, + "requires": { + "kleur": "^3.0.3", + "sisteransi": "^1.0.5" + } + }, + "punycode": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.0.tgz", + "integrity": "sha512-rRV+zQD8tVFys26lAGR9WUuS4iUAngJScM+ZRSKtvl5tKeZ2t5bvdNFdNHBW9FWR4guGHlgmsZ1G7BSm2wTbuA==", + "dev": true + }, + "pure-rand": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/pure-rand/-/pure-rand-6.0.2.tgz", + "integrity": "sha512-6Yg0ekpKICSjPswYOuC5sku/TSWaRYlA0qsXqJgM/d/4pLPHPuTxK7Nbf7jFKzAeedUhR8C7K9Uv63FBsSo8xQ==", + "dev": true + }, + "queue-microtask": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz", + "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==" + }, + "react-is": { + "version": "18.2.0", + "resolved": "https://registry.npmjs.org/react-is/-/react-is-18.2.0.tgz", + "integrity": "sha512-xWGDIW6x921xtzPkhiULtthJHoJvBbF3q26fzloPCK0hsvxtPVelvftw3zjbHWSkR2km9Z+4uxbDDK/6Zw9B8w==", + "dev": true + }, + "regexp.prototype.flags": { + "version": "1.5.0", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.2.0", + "functions-have-names": "^1.2.3" + } + }, + "require-directory": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", + "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==", + "dev": true + }, + "resolve": { + "version": "1.22.2", + "dev": true, + "requires": { + "is-core-module": "^2.11.0", + "path-parse": "^1.0.7", + "supports-preserve-symlinks-flag": "^1.0.0" + } + }, + "resolve-cwd": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/resolve-cwd/-/resolve-cwd-3.0.0.tgz", + "integrity": "sha512-OrZaX2Mb+rJCpH/6CpSqt9xFVpN++x01XnN2ie9g6P5/3xelLAkXWVADpdz1IHD/KFfEXyE6V0U01OQ3UO2rEg==", + "dev": true, + "requires": { + "resolve-from": "^5.0.0" + } + }, + "resolve-from": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz", + "integrity": "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==", + "dev": true + }, + "resolve.exports": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/resolve.exports/-/resolve.exports-2.0.2.tgz", + "integrity": "sha512-X2UW6Nw3n/aMgDVy+0rSqgHlv39WZAlZrXCdnbyEiKm17DSqHX4MmQMaST3FbeWR5FTuRcUwYAziZajji0Y7mg==", + "dev": true + }, + "reusify": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz", + "integrity": "sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==" + }, + "rimraf": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz", + "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==", + "dev": true, + "requires": { + "glob": "^7.1.3" + } + }, + "run-parallel": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz", + "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==", + "requires": { + "queue-microtask": "^1.2.2" + } + }, + "safe-regex-test": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/safe-regex-test/-/safe-regex-test-1.0.0.tgz", + "integrity": "sha512-JBUUzyOgEwXQY1NuPtvcj/qcBDbDmEvWufhlnXZIm75DEHp+afM1r1ujJpJsV/gSM4t59tpDyPi1sd6ZaPFfsA==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "get-intrinsic": "^1.1.3", + "is-regex": "^1.1.4" + } + }, + "semver": { + "version": "6.3.0", + "dev": true + }, + "sentence-case": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/sentence-case/-/sentence-case-3.0.4.tgz", + "integrity": "sha512-8LS0JInaQMCRoQ7YUytAo/xUu5W2XnQxV2HI/6uM6U7CITS1RqPElr30V6uIqyMKM9lJGRVFy5/4CuzcixNYSg==", + "dev": true, + "requires": { + "no-case": "^3.0.4", + "tslib": "^2.0.3", + "upper-case-first": "^2.0.2" + } + }, + "shebang-command": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", + "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", + "dev": true, + "requires": { + "shebang-regex": "^3.0.0" + } + }, + "shebang-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", + "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", + "dev": true + }, + "side-channel": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.4.tgz", + "integrity": "sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==", + "dev": true, + "requires": { + "call-bind": "^1.0.0", + "get-intrinsic": "^1.0.2", + "object-inspect": "^1.9.0" + } + }, + "signal-exit": { + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz", + "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==", + "dev": true + }, + "sisteransi": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/sisteransi/-/sisteransi-1.0.5.tgz", + "integrity": "sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==", + "dev": true + }, + "slash": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz", + "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==", + "dev": true + }, + "snake-case": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/snake-case/-/snake-case-3.0.4.tgz", + "integrity": "sha512-LAOh4z89bGQvl9pFfNF8V146i7o7/CqFPbqzYgP+yYzDIDeS9HaNFtXABamRW+AQzEVODcvE79ljJ+8a9YSdMg==", + "dev": true, + "requires": { + "dot-case": "^3.0.4", + "tslib": "^2.0.3" + } + }, + "source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "dev": true + }, + "source-map-support": { + "version": "0.5.13", + "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.13.tgz", + "integrity": "sha512-SHSKFHadjVA5oR4PPqhtAVdcBWwRYVd6g6cAXnIbRiIwc2EhPrTuKUBdSLvlEKyIP3GCf89fltvcZiP9MMFA1w==", + "dev": true, + "requires": { + "buffer-from": "^1.0.0", + "source-map": "^0.6.0" + } + }, + "sprintf-js": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz", + "integrity": "sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==", + "dev": true + }, + "stack-utils": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/stack-utils/-/stack-utils-2.0.6.tgz", + "integrity": "sha512-XlkWvfIm6RmsWtNJx+uqtKLS8eqFbxUg0ZzLXqY0caEy9l7hruX8IpiDnjsLavoBgqCCR71TqWO8MaXYheJ3RQ==", + "dev": true, + "requires": { + "escape-string-regexp": "^2.0.0" + }, + "dependencies": { + "escape-string-regexp": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-2.0.0.tgz", + "integrity": "sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==", + "dev": true + } + } + }, + "string-length": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/string-length/-/string-length-4.0.2.tgz", + "integrity": "sha512-+l6rNN5fYHNhZZy41RXsYptCjA2Igmq4EG7kZAYFQI1E1VTXarr6ZPXBg6eq7Y6eK4FEhY6AJlyuFIb/v/S0VQ==", + "dev": true, + "requires": { + "char-regex": "^1.0.2", + "strip-ansi": "^6.0.0" + } + }, + "string-width": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "dev": true, + "requires": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + } + }, + "string.prototype.trim": { + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.2.7.tgz", + "integrity": "sha512-p6TmeT1T3411M8Cgg9wBTMRtY2q9+PNy9EV1i2lIXUN/btt763oIfxwN3RR8VU6wHX8j/1CFy0L+YuThm6bgOg==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + } + }, + "string.prototype.trimend": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.6.tgz", + "integrity": "sha512-JySq+4mrPf9EsDBEDYMOb/lM7XQLulwg5R/m1r0PXEFqrV0qHvl58sdTilSXtKOflCsK2E8jxf+GKC0T07RWwQ==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + } + }, + "string.prototype.trimstart": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.6.tgz", + "integrity": "sha512-omqjMDaY92pbn5HOX7f9IccLA+U1tA9GvtU4JrodiXFfYB7jPzzHpRzpglLAjtUV6bB557zwClJezTqnAiYnQA==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + } + }, + "strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dev": true, + "requires": { + "ansi-regex": "^5.0.1" + } + }, + "strip-bom": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", + "integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==", + "dev": true + }, + "strip-final-newline": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-2.0.0.tgz", + "integrity": "sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==", + "dev": true + }, + "strip-json-comments": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz", + "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==", + "dev": true + }, + "supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dev": true, + "requires": { + "has-flag": "^4.0.0" + } + }, + "supports-preserve-symlinks-flag": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz", + "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==", + "dev": true + }, + "test-exclude": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/test-exclude/-/test-exclude-6.0.0.tgz", + "integrity": "sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==", + "dev": true, + "requires": { + "@istanbuljs/schema": "^0.1.2", + "glob": "^7.1.4", + "minimatch": "^3.0.4" + } + }, + "text-table": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz", + "integrity": "sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==", + "dev": true + }, + "tmpl": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/tmpl/-/tmpl-1.0.5.tgz", + "integrity": "sha512-3f0uOEAQwIqGuWW2MVzYg8fV/QNnc/IpuJNG837rLuczAaLVHslWHZQj4IGiEl5Hs3kkbhwL9Ab7Hrsmuj+Smw==", + "dev": true + }, + "to-fast-properties": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-2.0.0.tgz", + "integrity": "sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog==", + "dev": true + }, + "to-regex-range": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", + "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", + "requires": { + "is-number": "^7.0.0" + } + }, + "tr46": { + "version": "0.0.3", + "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz", + "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==" + }, + "ts-jest": { + "version": "29.1.0", + "dev": true, + "requires": { + "bs-logger": "0.x", + "fast-json-stable-stringify": "2.x", + "jest-util": "^29.0.0", + "json5": "^2.2.3", + "lodash.memoize": "4.x", + "make-error": "1.x", + "semver": "7.x", + "yargs-parser": "^21.0.1" + }, + "dependencies": { + "semver": { + "version": "7.5.2", + "dev": true, + "requires": { + "lru-cache": "^6.0.0" + } + } + } + }, + "ts-morph": { + "version": "20.0.0", + "resolved": "https://registry.npmjs.org/ts-morph/-/ts-morph-20.0.0.tgz", + "integrity": "sha512-JVmEJy2Wow5n/84I3igthL9sudQ8qzjh/6i4tmYCm6IqYyKFlNbJZi7oBdjyqcWSWYRu3CtL0xbT6fS03ESZIg==", + "requires": { + "@ts-morph/common": "~0.21.0", + "code-block-writer": "^12.0.0" + } + }, + "tsconfig-paths": { + "version": "3.14.2", + "dev": true, + "requires": { + "@types/json5": "^0.0.29", + "json5": "^1.0.2", + "minimist": "^1.2.6", + "strip-bom": "^3.0.0" + }, + "dependencies": { + "json5": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/json5/-/json5-1.0.2.tgz", + "integrity": "sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA==", + "dev": true, + "requires": { + "minimist": "^1.2.0" + } + } + } + }, + "tslib": { + "version": "2.5.3", + "dev": true + }, + "tsutils": { + "version": "3.21.0", + "resolved": "https://registry.npmjs.org/tsutils/-/tsutils-3.21.0.tgz", + "integrity": "sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA==", + "dev": true, + "requires": { + "tslib": "^1.8.1" + }, + "dependencies": { + "tslib": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz", + "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==", + "dev": true + } + } + }, + "tweetnacl": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/tweetnacl/-/tweetnacl-1.0.3.tgz", + "integrity": "sha512-6rt+RN7aOi1nGMyC4Xa5DdYiukl2UWCbcJft7YhxReBGQD7OAM8Pbxw6YMo4r2diNEA8FEmu32YOn9rhaiE5yw==" + }, + "type-check": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz", + "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==", + "dev": true, + "requires": { + "prelude-ls": "^1.2.1" + } + }, + "type-detect": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/type-detect/-/type-detect-4.0.8.tgz", + "integrity": "sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==", + "dev": true + }, + "type-fest": { + "version": "0.20.2", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz", + "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==", + "dev": true + }, + "typed-array-length": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/typed-array-length/-/typed-array-length-1.0.4.tgz", + "integrity": "sha512-KjZypGq+I/H7HI5HlOoGHkWUUGq+Q0TPhQurLbyrVrvnKTBgzLhIJ7j6J/XTQOi0d1RjyZ0wdas8bKs2p0x3Ng==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "for-each": "^0.3.3", + "is-typed-array": "^1.1.9" + } + }, + "typescript": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.0.2.tgz", + "integrity": "sha512-wVORMBGO/FAs/++blGNeAVdbNKtIh1rbBL2EyQ1+J9lClJ93KiiKe8PmFIVdXhHcyv44SL9oglmfeSsndo0jRw==", + "dev": true + }, + "unbox-primitive": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.0.2.tgz", + "integrity": "sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "has-bigints": "^1.0.2", + "has-symbols": "^1.0.3", + "which-boxed-primitive": "^1.0.2" + } + }, + "update-browserslist-db": { + "version": "1.0.11", + "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.0.11.tgz", + "integrity": "sha512-dCwEFf0/oT85M1fHBg4F0jtLwJrutGoHSQXCh7u4o2t1drG+c0a9Flnqww6XUKSfQMPpJBRjU8d4RXB09qtvaA==", + "dev": true, + "requires": { + "escalade": "^3.1.1", + "picocolors": "^1.0.0" + } + }, + "upper-case": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/upper-case/-/upper-case-2.0.2.tgz", + "integrity": "sha512-KgdgDGJt2TpuwBUIjgG6lzw2GWFRCW9Qkfkiv0DxqHHLYJHmtmdUIKcZd8rHgFSjopVTlw6ggzCm1b8MFQwikg==", + "dev": true, + "requires": { + "tslib": "^2.0.3" + } + }, + "upper-case-first": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/upper-case-first/-/upper-case-first-2.0.2.tgz", + "integrity": "sha512-514ppYHBaKwfJRK/pNC6c/OxfGa0obSnAl106u97Ed0I625Nin96KAjttZF6ZL3e1XLtphxnqrOi9iWgm+u+bg==", + "dev": true, + "requires": { + "tslib": "^2.0.3" + } + }, + "uri-js": { + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz", + "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==", + "dev": true, + "requires": { + "punycode": "^2.1.0" + } + }, + "v8-to-istanbul": { + "version": "9.1.0", + "resolved": "https://registry.npmjs.org/v8-to-istanbul/-/v8-to-istanbul-9.1.0.tgz", + "integrity": "sha512-6z3GW9x8G1gd+JIIgQQQxXuiJtCXeAjp6RaPEPLv62mH3iPHPxV6W3robxtCzNErRo6ZwTmzWhsbNvjyEBKzKA==", + "dev": true, + "requires": { + "@jridgewell/trace-mapping": "^0.3.12", + "@types/istanbul-lib-coverage": "^2.0.1", + "convert-source-map": "^1.6.0" + } + }, + "vlq": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/vlq/-/vlq-2.0.4.tgz", + "integrity": "sha512-aodjPa2wPQFkra1G8CzJBTHXhgk3EVSwxSWXNPr1fgdFLUb8kvLV1iEb6rFgasIsjP82HWI6dsb5Io26DDnasA==" + }, + "walker": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/walker/-/walker-1.0.8.tgz", + "integrity": "sha512-ts/8E8l5b7kY0vlWLewOkDXMmPdLcVV4GmOQLyxuSswIJsweeFZtAsMF7k1Nszz+TYBQrlYRmzOnr398y1JemQ==", + "dev": true, + "requires": { + "makeerror": "1.0.12" + } + }, + "webidl-conversions": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz", + "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==" + }, + "whatwg-url": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz", + "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==", + "requires": { + "tr46": "~0.0.3", + "webidl-conversions": "^3.0.0" + } + }, + "which": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "dev": true, + "requires": { + "isexe": "^2.0.0" + } + }, + "which-boxed-primitive": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/which-boxed-primitive/-/which-boxed-primitive-1.0.2.tgz", + "integrity": "sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg==", + "dev": true, + "requires": { + "is-bigint": "^1.0.1", + "is-boolean-object": "^1.1.0", + "is-number-object": "^1.0.4", + "is-string": "^1.0.5", + "is-symbol": "^1.0.3" + } + }, + "which-typed-array": { + "version": "1.1.9", + "dev": true, + "requires": { + "available-typed-arrays": "^1.0.5", + "call-bind": "^1.0.2", + "for-each": "^0.3.3", + "gopd": "^1.0.1", + "has-tostringtag": "^1.0.0", + "is-typed-array": "^1.1.10" + } + }, + "word-wrap": { + "version": "1.2.3", + "dev": true + }, + "wrap-ansi": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", + "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", + "dev": true, + "requires": { + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" + } + }, + "wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==", + "dev": true + }, + "write-file-atomic": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-4.0.2.tgz", + "integrity": "sha512-7KxauUdBmSdWnmpaGFg+ppNjKF8uNLry8LyzjauQDOVONfFLNKrKvQOxZ/VuTIcS/gge/YNahf5RIIQWTSarlg==", + "dev": true, + "requires": { + "imurmurhash": "^0.1.4", + "signal-exit": "^3.0.7" + } + }, + "y18n": { + "version": "5.0.8", + "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz", + "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==", + "dev": true + }, + "yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==", + "dev": true + }, + "yargs": { + "version": "17.7.2", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz", + "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==", + "dev": true, + "requires": { + "cliui": "^8.0.1", + "escalade": "^3.1.1", + "get-caller-file": "^2.0.5", + "require-directory": "^2.1.1", + "string-width": "^4.2.3", + "y18n": "^5.0.5", + "yargs-parser": "^21.1.1" + } + }, + "yargs-parser": { + "version": "21.1.1", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz", + "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==", + "dev": true + }, + "yocto-queue": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", + "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", + "dev": true + } + } +} diff --git a/reference_contract/package.json b/reference_contract/package.json new file mode 100644 index 0000000..2e05417 --- /dev/null +++ b/reference_contract/package.json @@ -0,0 +1,31 @@ +{ + "name": "algo-did", + "version": "0.0.0", + "license": "MIT", + "scripts": { + "compile-contract": "tealscript contracts/algo-did.algo.ts contracts/artifacts", + "generate-client": "algokitgen generate -a contracts/artifacts/AlgoDID.json -o contracts/clients/AlgoDIDClient.ts", + "build": "npm run compile-contract", + "test": "npm run build && jest", + "lint": "eslint . --ext .ts", + "fix": "eslint . --ext .ts --fix" + }, + "dependencies": { + "@algorandfoundation/algokit-utils": "^5.1.3", + "@algorandfoundation/tealscript": "^0.51.1", + "algosdk": "^2.6.0" + }, + "devDependencies": { + "@algorandfoundation/algokit-client-generator": "^2.2.1", + "@jest/globals": "^29.5.0", + "@typescript-eslint/eslint-plugin": "^5.13.0", + "@typescript-eslint/parser": "^5.0.0", + "eslint": "^7.32.0 || ^8.2.0", + "eslint-config-airbnb-base": "^15.0.0", + "eslint-config-airbnb-typescript": "^17.0.0", + "eslint-plugin-import": "^2.25.2", + "jest": "^29.5.0", + "ts-jest": "^29.1.0", + "typescript": "5.0.2" + } +} diff --git a/reference_contract/src/index.ts b/reference_contract/src/index.ts new file mode 100644 index 0000000..b598bf2 --- /dev/null +++ b/reference_contract/src/index.ts @@ -0,0 +1,362 @@ +/* eslint-disable no-await-in-loop */ +/* eslint-disable no-restricted-syntax */ +import algosdk, { ABIMethod, ABIResult } from 'algosdk'; +import { ApplicationClient } from '@algorandfoundation/algokit-utils/types/app-client'; +import { AppCallTransactionResult } from '@algorandfoundation/algokit-utils/types/app'; +import { expect } from '@jest/globals'; +import { SuggestedParamsWithMinFee } from 'algosdk/dist/types/types/transactions/base'; +import appSpec from '../contracts/artifacts/AlgoDID.json'; + +const COST_PER_BYTE = 400; +const COST_PER_BOX = 2500; +const MAX_BOX_SIZE = 32768; + +const BYTES_PER_CALL = 2048 +- 4 // 4 bytes for the method selector +- 34 // 34 bytes for the key +- 8 // 8 bytes for the box index +- 8; // 8 bytes for the offset + +export type Metadata = {start: bigint, end: bigint, status: bigint, endSize: bigint}; + +export async function resolveDID(did: string, algodClient: algosdk.Algodv2): Promise { + const splitDid = did.split(':'); + + if (splitDid[0] !== 'did') throw new Error(`Invalid protocol. Expected 'did', got ${splitDid[0]}`); + if (splitDid[1] !== 'algo') throw new Error(`Invalid DID method. Expected 'algod', got ${splitDid[1]}`); + + const splitID = splitDid[2].split('-'); + + let pubKey: Uint8Array; + try { + pubKey = algosdk.decodeAddress(splitID[0]).publicKey; + } catch (e) { + throw new Error(`Invalid public key. Expected Algorand address, got ${splitID[0]}`); + } + + let appID: bigint; + + try { + appID = BigInt(splitID[1]); + algosdk.encodeUint64(appID); + } catch (e) { + throw new Error(`Invalid app ID. Expected uint64, got ${splitID[1]}`); + } + + const appClient = new ApplicationClient({ + resolveBy: 'id', + id: appID, + sender: algosdk.generateAccount(), + app: JSON.stringify(appSpec), + }, algodClient); + + const boxValue = (await appClient.getBoxValueFromABIType(pubKey, algosdk.ABIType.from('(uint64,uint64,uint8,uint64,uint64)'))).valueOf() as bigint[]; + + const metadata: Metadata = { + start: boxValue[0], end: boxValue[1], status: boxValue[2], endSize: boxValue[3], + }; + + if (metadata.status === BigInt(0)) throw new Error('DID document is still being uploaded'); + if (metadata.status === BigInt(2)) throw new Error('DID document is being deleted'); + + const boxPromises = []; + for (let i = metadata.start; i <= metadata.end; i += 1n) { + boxPromises.push(appClient.getBoxValue(algosdk.encodeUint64(i))); + } + + const boxValues = await Promise.all(boxPromises); + + return Buffer.concat(boxValues); +} + +/** + * + * @param algodClient + * @param abiMethod + * @param pubKey + * @param boxes + * @param boxIndex + * @param suggestedParams + * @param sender + * @param appID + * @param group + * @returns + */ +export async function sendTxGroup( + algodClient: algosdk.Algodv2, + abiMethod: ABIMethod, + bytesOffset: number, + pubKey: Uint8Array, + boxes: algosdk.BoxReference[], + boxIndex: bigint, + suggestedParams: SuggestedParamsWithMinFee, + sender: algosdk.Account, + appID: number, + group: Buffer[], +): Promise { + const atc = new algosdk.AtomicTransactionComposer(); + group.forEach((chunk, i) => { + atc.addMethodCall({ + method: abiMethod!, + methodArgs: [pubKey, boxIndex, BYTES_PER_CALL * (i + bytesOffset), chunk], + boxes, + suggestedParams, + sender: sender.addr, + signer: algosdk.makeBasicAccountTransactionSigner(sender), + appID, + }); + }); + + await new Promise((r) => setTimeout(r, 2000)); + return (await atc.execute(algodClient, 3)).txIDs; +} + +/** + * + * @param atc + * @param algodClient + * @param retryCount + */ +async function tryExecute( + atc: algosdk.AtomicTransactionComposer, + algodClient: algosdk.Algodv2, + retryCount = 1, +): Promise { + try { + await atc.execute(algodClient, 3); + } catch (e) { + if (retryCount === 3) { + // TODO: SDK bugfix + // const execTraceConfig = new algosdk.modelsv2.SimulateTraceConfig({ + // enable: true, + // stackChange: true, + // stateChange: true, + // scratchChange: true, + // }); + + // const simReq = new algosdk.modelsv2.SimulateRequest({ + // txnGroups: [], + // execTraceConfig, + // }); + // const result = await atc.simulate(algodClient, simReq); + + // console.warn(result.simulateResponse.txnGroups[0].txnResults[0].execTrace); + throw e; + } + + // eslint-disable-next-line no-console + console.warn(`Failed to send transaction group. Retrying in ${500 * retryCount}ms (${retryCount / 3})`); + } +} + +/** + * + * @param data + * @param appID + * @param pubKey + * @param sender + * @param algodClient + * @returns + */ +export async function uploadDIDDocument( + data: Buffer, + appID: number, + pubKey: Uint8Array, + sender: algosdk.Account, + algodClient: algosdk.Algodv2, +): Promise { + const appClient = new ApplicationClient({ + resolveBy: 'id', + id: appID, + sender, + app: JSON.stringify(appSpec), + }, algodClient); + + const ceilBoxes = Math.ceil(data.byteLength / MAX_BOX_SIZE); + + const endBoxSize = data.byteLength % MAX_BOX_SIZE; + + const totalCost = ceilBoxes * COST_PER_BOX // cost of data boxes + + (ceilBoxes - 1) * MAX_BOX_SIZE * COST_PER_BYTE // cost of data + + ceilBoxes * 8 * COST_PER_BYTE // cost of data keys + + endBoxSize * COST_PER_BYTE // cost of last data box + + COST_PER_BOX + (8 + 8 + 1 + 8 + 32 + 8) * COST_PER_BYTE; // cost of metadata box + + const mbrPayment = algosdk.makePaymentTxnWithSuggestedParamsFromObject({ + from: sender.addr, + to: (await appClient.getAppReference()).appAddress, + amount: totalCost, + suggestedParams: await algodClient.getTransactionParams().do(), + }); + + const appCallResult: AppCallTransactionResult = await appClient.call({ + method: 'startUpload', + methodArgs: [pubKey, ceilBoxes, endBoxSize, mbrPayment], + boxes: [ + pubKey, + ], + sendParams: { suppressLog: true }, + }); + expect(appCallResult).toBeDefined(); + + const boxValue = (await appClient.getBoxValueFromABIType(pubKey, algosdk.ABIType.from('(uint64,uint64,uint8,uint64,uint64)'))).valueOf() as bigint[]; + + const metadata: Metadata = { + start: boxValue[0], end: boxValue[1], status: boxValue[2], endSize: boxValue[3], + }; + + const numBoxes = Math.floor(data.byteLength / MAX_BOX_SIZE); + const boxData: Buffer[] = []; + + for (let i = 0; i < numBoxes; i += 1) { + const box = data.subarray(i * MAX_BOX_SIZE, (i + 1) * MAX_BOX_SIZE); + boxData.push(box); + } + + boxData.push(data.subarray(numBoxes * MAX_BOX_SIZE, data.byteLength)); + + const suggestedParams: SuggestedParamsWithMinFee = await algodClient.getTransactionParams().do(); + + const boxPromises = boxData.map(async (box, boxIndexOffset) => { + const boxIndex = metadata.start + BigInt(boxIndexOffset); + const numChunks = Math.ceil(box.byteLength / BYTES_PER_CALL); + + const chunks: Buffer[] = []; + + for (let i = 0; i < numChunks; i += 1) { + chunks.push(box.subarray(i * BYTES_PER_CALL, (i + 1) * BYTES_PER_CALL)); + } + + const boxRef = { appIndex: 0, name: algosdk.encodeUint64(boxIndex) }; + const boxes: algosdk.BoxReference[] = new Array(7).fill(boxRef); + + boxes.push({ appIndex: 0, name: pubKey }); + + const firstGroup = chunks.slice(0, 8); + const secondGroup = chunks.slice(8); + + await sendTxGroup(algodClient, appClient.getABIMethod('upload')!, 0, pubKey, boxes, boxIndex, suggestedParams, sender, appID, firstGroup); + + if (secondGroup.length === 0) return; + + await sendTxGroup(algodClient, appClient.getABIMethod('upload')!, 8, pubKey, boxes, boxIndex, suggestedParams, sender, appID, secondGroup); + }); + + await Promise.all(boxPromises); + if (Buffer.concat(boxData).toString('hex') !== data.toString('hex')) throw new Error('Data validation failed!'); + + await appClient.call({ + method: 'finishUpload', + methodArgs: [pubKey], + boxes: [ + pubKey, + ], + sendParams: { suppressLog: true }, + }); + + return metadata; +} + +/* +export async function uploadDIDDocument( + data: Buffer, + appID: number, + pubKey: Uint8Array, + sender: algosdk.Account, + algodClient: algosdk.Algodv2, +): Promise { + */ +export async function deleteDIDDocument( + appID: number, + pubKey: Uint8Array, + sender: algosdk.Account, + algodClient: algosdk.Algodv2, +): Promise { + const appClient = new ApplicationClient({ + resolveBy: 'id', + id: appID, + sender: algosdk.generateAccount(), + app: JSON.stringify(appSpec), + }, algodClient); + + const boxValue = (await appClient.getBoxValueFromABIType(pubKey, algosdk.ABIType.from('(uint64,uint64,uint8,uint64,uint64)'))).valueOf() as bigint[]; + + const metadata: Metadata = { + start: boxValue[0], end: boxValue[1], status: boxValue[2], endSize: boxValue[3], + }; + + await appClient.call({ + method: 'startDelete', + methodArgs: [pubKey], + boxes: [ + pubKey, + ], + sender, + sendParams: { suppressLog: true }, + }); + + const suggestedParams = await algodClient.getTransactionParams().do(); + + const atcs: {boxIndex: bigint, atc: algosdk.AtomicTransactionComposer}[] = []; + for (let boxIndex = metadata.start; boxIndex <= metadata.end; boxIndex += 1n) { + const atc = new algosdk.AtomicTransactionComposer(); + const boxIndexRef = { appIndex: appID, name: algosdk.encodeUint64(boxIndex) }; + atc.addMethodCall({ + appID, + method: appClient.getABIMethod('deleteData')!, + methodArgs: [pubKey, boxIndex], + boxes: [ + { appIndex: appID, name: pubKey }, + boxIndexRef, + boxIndexRef, + boxIndexRef, + boxIndexRef, + boxIndexRef, + boxIndexRef, + boxIndexRef, + ], + suggestedParams: { ...suggestedParams, fee: 2000, flatFee: true }, + sender: sender.addr, + signer: algosdk.makeBasicAccountTransactionSigner(sender), + }); + + for (let i = 0; i < 4; i += 1) { + atc.addMethodCall({ + appID, + method: appClient.getABIMethod('dummy')!, + methodArgs: [], + boxes: [ + boxIndexRef, + boxIndexRef, + boxIndexRef, + boxIndexRef, + boxIndexRef, + boxIndexRef, + boxIndexRef, + boxIndexRef, + ], + suggestedParams, + sender: sender.addr, + signer: algosdk.makeBasicAccountTransactionSigner(sender), + note: new Uint8Array(Buffer.from(`dummy ${i}`)), + }); + } + + atcs.push({ atc, boxIndex }); + } + + for await (const atcAndIndex of atcs) { + await tryExecute(atcAndIndex.atc, algodClient); + } +} + +export async function updateDIDDocument( + data: Buffer, + appID: number, + pubKey: Uint8Array, + sender: algosdk.Account, + algodClient: algosdk.Algodv2, +): Promise { + await deleteDIDDocument(appID, pubKey, sender, algodClient); + return uploadDIDDocument(data, appID, pubKey, sender, algodClient); +} diff --git a/reference_contract/tsconfig.json b/reference_contract/tsconfig.json new file mode 100644 index 0000000..a74f6dc --- /dev/null +++ b/reference_contract/tsconfig.json @@ -0,0 +1,103 @@ +{ + "compilerOptions": { + /* Visit https://aka.ms/tsconfig to read more about this file */ + + /* Projects */ + // "incremental": true, /* Save .tsbuildinfo files to allow for incremental compilation of projects. */ + // "composite": true, /* Enable constraints that allow a TypeScript project to be used with project references. */ + // "tsBuildInfoFile": "./.tsbuildinfo", /* Specify the path to .tsbuildinfo incremental compilation file. */ + // "disableSourceOfProjectReferenceRedirect": true, /* Disable preferring source files instead of declaration files when referencing composite projects. */ + // "disableSolutionSearching": true, /* Opt a project out of multi-project reference checking when editing. */ + // "disableReferencedProjectLoad": true, /* Reduce the number of projects loaded automatically by TypeScript. */ + + /* Language and Environment */ + "target": "es2020", /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */ + // "lib": [], /* Specify a set of bundled library declaration files that describe the target runtime environment. */ + // "jsx": "preserve", /* Specify what JSX code is generated. */ + "experimentalDecorators": true, /* Enable experimental support for TC39 stage 2 draft decorators. */ + // "emitDecoratorMetadata": true, /* Emit design-type metadata for decorated declarations in source files. */ + // "jsxFactory": "", /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */ + // "jsxFragmentFactory": "", /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */ + // "jsxImportSource": "", /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */ + // "reactNamespace": "", /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */ + // "noLib": true, /* Disable including any library files, including the default lib.d.ts. */ + // "useDefineForClassFields": true, /* Emit ECMAScript-standard-compliant class fields. */ + // "moduleDetection": "auto", /* Control what method is used to detect module-format JS files. */ + + /* Modules */ + "module": "commonjs", /* Specify what module code is generated. */ + // "rootDir": "./", /* Specify the root folder within your source files. */ + // "moduleResolution": "node", /* Specify how TypeScript looks up a file from a given module specifier. */ + // "baseUrl": "./", /* Specify the base directory to resolve non-relative module names. */ + // "paths": {}, /* Specify a set of entries that re-map imports to additional lookup locations. */ + // "rootDirs": [], /* Allow multiple folders to be treated as one when resolving modules. */ + // "typeRoots": [], /* Specify multiple folders that act like './node_modules/@types'. */ + // "types": [], /* Specify type package names to be included without being referenced in a source file. */ + // "allowUmdGlobalAccess": true, /* Allow accessing UMD globals from modules. */ + // "moduleSuffixes": [], /* List of file name suffixes to search when resolving a module. */ + "resolveJsonModule": true, /* Enable importing .json files. */ + // "noResolve": true, /* Disallow 'import's, 'require's or ''s from expanding the number of files TypeScript should add to a project. */ + + /* JavaScript Support */ + // "allowJs": true, /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */ + // "checkJs": true, /* Enable error reporting in type-checked JavaScript files. */ + // "maxNodeModuleJsDepth": 1, /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */ + + /* Emit */ + // "declaration": true, /* Generate .d.ts files from TypeScript and JavaScript files in your project. */ + // "declarationMap": true, /* Create sourcemaps for d.ts files. */ + // "emitDeclarationOnly": true, /* Only output d.ts files and not JavaScript files. */ + // "sourceMap": true, /* Create source map files for emitted JavaScript files. */ + // "outFile": "./", /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */ + // "outDir": "./", /* Specify an output folder for all emitted files. */ + // "removeComments": true, /* Disable emitting comments. */ + // "noEmit": true, /* Disable emitting files from a compilation. */ + // "importHelpers": true, /* Allow importing helper functions from tslib once per project, instead of including them per-file. */ + // "importsNotUsedAsValues": "remove", /* Specify emit/checking behavior for imports that are only used for types. */ + // "downlevelIteration": true, /* Emit more compliant, but verbose and less performant JavaScript for iteration. */ + // "sourceRoot": "", /* Specify the root path for debuggers to find the reference source code. */ + // "mapRoot": "", /* Specify the location where debugger should locate map files instead of generated locations. */ + // "inlineSourceMap": true, /* Include sourcemap files inside the emitted JavaScript. */ + // "inlineSources": true, /* Include source code in the sourcemaps inside the emitted JavaScript. */ + // "emitBOM": true, /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */ + // "newLine": "crlf", /* Set the newline character for emitting files. */ + // "stripInternal": true, /* Disable emitting declarations that have '@internal' in their JSDoc comments. */ + // "noEmitHelpers": true, /* Disable generating custom helper functions like '__extends' in compiled output. */ + // "noEmitOnError": true, /* Disable emitting files if any type checking errors are reported. */ + // "preserveConstEnums": true, /* Disable erasing 'const enum' declarations in generated code. */ + // "declarationDir": "./", /* Specify the output directory for generated declaration files. */ + // "preserveValueImports": true, /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */ + + /* Interop Constraints */ + // "isolatedModules": true, /* Ensure that each file can be safely transpiled without relying on other imports. */ + // "allowSyntheticDefaultImports": true, /* Allow 'import x from y' when a module doesn't have a default export. */ + "esModuleInterop": true, /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */ + // "preserveSymlinks": true, /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */ + "forceConsistentCasingInFileNames": true, /* Ensure that casing is correct in imports. */ + + /* Type Checking */ + "strict": true, /* Enable all strict type-checking options. */ + // "noImplicitAny": true, /* Enable error reporting for expressions and declarations with an implied 'any' type. */ + // "strictNullChecks": true, /* When type checking, take into account 'null' and 'undefined'. */ + // "strictFunctionTypes": true, /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */ + // "strictBindCallApply": true, /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */ + // "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */ + // "noImplicitThis": true, /* Enable error reporting when 'this' is given the type 'any'. */ + // "useUnknownInCatchVariables": true, /* Default catch clause variables as 'unknown' instead of 'any'. */ + // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */ + // "noUnusedLocals": true, /* Enable error reporting when local variables aren't read. */ + // "noUnusedParameters": true, /* Raise an error when a function parameter isn't read. */ + // "exactOptionalPropertyTypes": true, /* Interpret optional property types as written, rather than adding 'undefined'. */ + // "noImplicitReturns": true, /* Enable error reporting for codepaths that do not explicitly return in a function. */ + // "noFallthroughCasesInSwitch": true, /* Enable error reporting for fallthrough cases in switch statements. */ + // "noUncheckedIndexedAccess": true, /* Add 'undefined' to a type when accessed using an index. */ + // "noImplicitOverride": true, /* Ensure overriding members in derived classes are marked with an override modifier. */ + // "noPropertyAccessFromIndexSignature": true, /* Enforces using indexed accessors for keys declared using an indexed type. */ + // "allowUnusedLabels": true, /* Disable error reporting for unused labels. */ + // "allowUnreachableCode": true, /* Disable error reporting for unreachable code. */ + + /* Completeness */ + // "skipDefaultLibCheck": true, /* Skip type checking .d.ts files that are included with TypeScript. */ + "skipLibCheck": true /* Skip type checking all .d.ts files. */ + } +} From 2b636a66f07d88e03823b9c89e911e91e3dcedce Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Wed, 19 Jun 2024 13:27:05 -0400 Subject: [PATCH 3/9] update TEALScript and generate artifacts --- reference_contract/.gitignore | 3 +- reference_contract/contracts/algo-did.algo.ts | 9 +- .../contracts/artifacts/.gitkeep | 0 .../contracts/artifacts/AlgoDID.abi.json | 143 + .../contracts/artifacts/AlgoDID.approval.teal | 676 ++++ .../contracts/artifacts/AlgoDID.arc32.json | 214 ++ .../contracts/artifacts/AlgoDID.arc4.json | 134 + .../artifacts/AlgoDID.arc56_draft.json | 3189 +++++++++++++++++ .../contracts/artifacts/AlgoDID.clear.teal | 1 + .../contracts/artifacts/AlgoDID.json | 223 ++ .../contracts/artifacts/AlgoDID.src_map.json | 2936 +++++++++++++++ reference_contract/package-lock.json | 610 +++- reference_contract/package.json | 2 +- 13 files changed, 8076 insertions(+), 64 deletions(-) create mode 100644 reference_contract/contracts/artifacts/.gitkeep create mode 100644 reference_contract/contracts/artifacts/AlgoDID.abi.json create mode 100644 reference_contract/contracts/artifacts/AlgoDID.approval.teal create mode 100644 reference_contract/contracts/artifacts/AlgoDID.arc32.json create mode 100644 reference_contract/contracts/artifacts/AlgoDID.arc4.json create mode 100644 reference_contract/contracts/artifacts/AlgoDID.arc56_draft.json create mode 100644 reference_contract/contracts/artifacts/AlgoDID.clear.teal create mode 100644 reference_contract/contracts/artifacts/AlgoDID.json create mode 100644 reference_contract/contracts/artifacts/AlgoDID.src_map.json diff --git a/reference_contract/.gitignore b/reference_contract/.gitignore index bd0a936..40b878d 100644 --- a/reference_contract/.gitignore +++ b/reference_contract/.gitignore @@ -1,2 +1 @@ -node_modules/ -contracts/artifacts \ No newline at end of file +node_modules/ \ No newline at end of file diff --git a/reference_contract/contracts/algo-did.algo.ts b/reference_contract/contracts/algo-did.algo.ts index 248aced..74901f9 100644 --- a/reference_contract/contracts/algo-did.algo.ts +++ b/reference_contract/contracts/algo-did.algo.ts @@ -23,20 +23,19 @@ type Metadata = { }; /** Indicates the data is still being uploaded */ -const UPLOADING: uint<8> = 0; +const UPLOADING = >0; /** Indicates the data is done uploading and can be safely read */ -const READY: uint<8> = 1; +const READY = >1; /** Indicates the data is currently being deleted */ -const DELETING: uint<8> = 2; +const DELETING = >2; const COST_PER_BYTE = 400; const COST_PER_BOX = 2500; const MAX_BOX_SIZE = 32768; -// eslint-disable-next-line no-unused-vars -class AlgoDID extends Contract { +export class AlgoDID extends Contract { /** The boxes that contain the data, indexed by uint64 */ dataBoxes = BoxMap(); diff --git a/reference_contract/contracts/artifacts/.gitkeep b/reference_contract/contracts/artifacts/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/reference_contract/contracts/artifacts/AlgoDID.abi.json b/reference_contract/contracts/artifacts/AlgoDID.abi.json new file mode 100644 index 0000000..a62273e --- /dev/null +++ b/reference_contract/contracts/artifacts/AlgoDID.abi.json @@ -0,0 +1,143 @@ +{ + "name": "AlgoDID", + "desc": "", + "methods": [ + { + "name": "startUpload", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The pubkey of the DID" + }, + { + "name": "numBoxes", + "type": "uint64", + "desc": "The number of boxes that the data will take up" + }, + { + "name": "endBoxSize", + "type": "uint64", + "desc": "The size of the last box" + }, + { + "name": "mbrPayment", + "type": "pay", + "desc": "Payment from the uploader to cover the box MBR" + } + ], + "desc": "Allocate boxes to begin data upload process", + "returns": { + "type": "void", + "desc": "" + } + }, + { + "name": "upload", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The pubkey of the DID" + }, + { + "name": "boxIndex", + "type": "uint64", + "desc": "The index of the box to upload the given chunk of data to" + }, + { + "name": "offset", + "type": "uint64", + "desc": "The offset within the box to start writing the data" + }, + { + "name": "data", + "type": "byte[]", + "desc": "The data to write" + } + ], + "desc": "Upload data to a specific offset in a box", + "returns": { + "type": "void", + "desc": "" + } + }, + { + "name": "finishUpload", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + } + ], + "desc": "Mark uploading as false", + "returns": { + "type": "void", + "desc": "" + } + }, + { + "name": "startDelete", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + } + ], + "desc": "Starts the deletion process for the data associated with a DID", + "returns": { + "type": "void", + "desc": "" + } + }, + { + "name": "deleteData", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + }, + { + "name": "boxIndex", + "type": "uint64", + "desc": "The index of the box to delete" + } + ], + "desc": "Deletes a box of data", + "returns": { + "type": "void", + "desc": "" + } + }, + { + "name": "updateApplication", + "args": [], + "desc": "Allow the contract to be updated by the creator", + "returns": { + "type": "void", + "desc": "" + } + }, + { + "name": "dummy", + "args": [], + "desc": "Dummy function to add extra box references for deleteData.Boxes are 32k, but a single app call can only inlcude enough references to read/write 8kat a time. Thus when a box is deleted, we need to add additional dummy calls with boxreferences to increase the total read/write budget to 32k.", + "returns": { + "type": "void", + "desc": "" + } + }, + { + "name": "createApplication", + "desc": "", + "returns": { + "type": "void", + "desc": "" + }, + "args": [] + } + ] +} \ No newline at end of file diff --git a/reference_contract/contracts/artifacts/AlgoDID.approval.teal b/reference_contract/contracts/artifacts/AlgoDID.approval.teal new file mode 100644 index 0000000..a9cdc96 --- /dev/null +++ b/reference_contract/contracts/artifacts/AlgoDID.approval.teal @@ -0,0 +1,676 @@ +#pragma version 10 + +// This TEAL was generated by TEALScript v0.96.0 +// https://github.com/algorandfoundation/TEALScript + +// This contract is compliant with and/or implements the following ARCs: [ ARC4 ] + +// The following ten lines of TEAL handle initial program flow +// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed +// Here, action refers to the OnComplete in combination with whether the app is being created or called +// Every possible action for this contract is represented in the switch statement +// If the action is not implemented in the contract, its respective branch will be "*NOT_IMPLEMENTED" which just contains "err" +txn ApplicationID +! +int 6 +* +txn OnCompletion ++ +switch *call_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *call_UpdateApplication *NOT_IMPLEMENTED *create_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED + +*NOT_IMPLEMENTED: + // The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID? + err + +// startUpload(address,uint64,uint64,pay)void +*abi_route_startUpload: + // mbrPayment: pay + txn GroupIndex + int 1 + - + dup + gtxns TypeEnum + int pay + == + + // argument 0 (mbrPayment) for startUpload must be a pay transaction + assert + + // endBoxSize: uint64 + txna ApplicationArgs 3 + btoi + + // numBoxes: uint64 + txna ApplicationArgs 2 + btoi + + // pubKey: address + txna ApplicationArgs 1 + dup + len + int 32 + == + + // argument 3 (pubKey) for startUpload must be a address + assert + + // execute startUpload(address,uint64,uint64,pay)void + callsub startUpload + int 1 + return + +// startUpload(pubKey: Address, numBoxes: uint64, endBoxSize: uint64, mbrPayment: PayTxn): void +// +// +// Allocate boxes to begin data upload process +// +// @param pubKey The pubkey of the DID +// @param numBoxes The number of boxes that the data will take up +// @param endBoxSize The size of the last box +// @param mbrPayment Payment from the uploader to cover the box MBR +startUpload: + proto 4 0 + + // Push empty bytes after the frame pointer to reserve space for local variables + byte 0x + dupn 3 + + // contracts/algo-did.algo.ts:63 + // assert(this.txn.sender === globals.creatorAddress) + txn Sender + global CreatorAddress + == + assert + + // contracts/algo-did.algo.ts:65 + // startBox = this.currentIndex.value + byte 0x63757272656e74496e646578 // "currentIndex" + app_global_get + frame_bury 0 // startBox: uint64 + + // contracts/algo-did.algo.ts:66 + // endBox = startBox + numBoxes - 1 + frame_dig 0 // startBox: uint64 + frame_dig -2 // numBoxes: uint64 + + + int 1 + - + frame_bury 1 // endBox: uint64 + + // contracts/algo-did.algo.ts:68 + // metadata: Metadata = { + // start: startBox, end: endBox, status: UPLOADING, endSize: endBoxSize, lastDeleted: 0, + // } + frame_dig 0 // startBox: uint64 + itob + frame_dig 1 // endBox: uint64 + itob + concat + byte 0x00 + concat + frame_dig -3 // endBoxSize: uint64 + itob + concat + byte 0x0000000000000000 + concat + frame_bury 2 // metadata: Metadata + + // contracts/algo-did.algo.ts:72 + // assert(!this.metadata(pubKey).exists) + frame_dig -1 // pubKey: Address + box_len + swap + pop + ! + assert + + // contracts/algo-did.algo.ts:74 + // this.metadata(pubKey).value = metadata + frame_dig -1 // pubKey: Address + frame_dig 2 // metadata: Metadata + box_put + + // contracts/algo-did.algo.ts:76 + // this.currentIndex.value = endBox + 1 + byte 0x63757272656e74496e646578 // "currentIndex" + frame_dig 1 // endBox: uint64 + int 1 + + + app_global_put + + // contracts/algo-did.algo.ts:78 + // totalCost = numBoxes * COST_PER_BOX // cost of data boxes + // + (numBoxes - 1) * MAX_BOX_SIZE * COST_PER_BYTE // cost of data + // + numBoxes * 8 * COST_PER_BYTE // cost of data keys + // + endBoxSize * COST_PER_BYTE // cost of last data box + // + COST_PER_BOX + (8 + 8 + 1 + 8 + 32 + 8) * COST_PER_BYTE + frame_dig -2 // numBoxes: uint64 + int 2500 + * + frame_dig -2 // numBoxes: uint64 + int 1 + - + int 32768 + * + int 400 + * + + + frame_dig -2 // numBoxes: uint64 + int 8 + * + int 400 + * + + + frame_dig -3 // endBoxSize: uint64 + int 400 + * + + + int 2500 + + + int 26000 + + + frame_bury 3 // totalCost: uint64 + + // contracts/algo-did.algo.ts:84 + // assert(mbrPayment.amount === totalCost) + frame_dig -4 // mbrPayment: PayTxn + gtxns Amount + frame_dig 3 // totalCost: uint64 + == + assert + + // contracts/algo-did.algo.ts:85 + // assert(mbrPayment.receiver === this.app.address) + frame_dig -4 // mbrPayment: PayTxn + gtxns Receiver + global CurrentApplicationAddress + == + assert + retsub + +// upload(address,uint64,uint64,byte[])void +*abi_route_upload: + // data: byte[] + txna ApplicationArgs 4 + extract 2 0 + + // offset: uint64 + txna ApplicationArgs 3 + btoi + + // boxIndex: uint64 + txna ApplicationArgs 2 + btoi + + // pubKey: address + txna ApplicationArgs 1 + dup + len + int 32 + == + + // argument 3 (pubKey) for upload must be a address + assert + + // execute upload(address,uint64,uint64,byte[])void + callsub upload + int 1 + return + +// upload(pubKey: Address, boxIndex: uint64, offset: uint64, data: bytes): void +// +// +// Upload data to a specific offset in a box +// +// @param pubKey The pubkey of the DID +// @param boxIndex The index of the box to upload the given chunk of data to +// @param offset The offset within the box to start writing the data +// @param data The data to write +upload: + proto 4 0 + + // Push empty bytes after the frame pointer to reserve space for local variables + byte 0x + + // contracts/algo-did.algo.ts:98 + // assert(this.txn.sender === globals.creatorAddress) + txn Sender + global CreatorAddress + == + assert + + // contracts/algo-did.algo.ts:100 + // metadata = this.metadata(pubKey).value + frame_dig -1 // pubKey: Address + frame_bury 0 // storage key//metadata + + // contracts/algo-did.algo.ts:101 + // assert(metadata.status === UPLOADING) + frame_dig -1 // pubKey: Address + int 16 // headOffset + int 1 + box_extract + btoi + int 0 + == + assert + + // contracts/algo-did.algo.ts:102 + // assert(metadata.start <= boxIndex && boxIndex <= metadata.end) + frame_dig -1 // pubKey: Address + int 0 + int 8 + box_extract + btoi + frame_dig -2 // boxIndex: uint64 + <= + dup + bz *skip_and0 + frame_dig -2 // boxIndex: uint64 + frame_dig -1 // pubKey: Address + int 8 // headOffset + int 8 + box_extract + btoi + <= + && + +*skip_and0: + assert + + // *if0_condition + // contracts/algo-did.algo.ts:104 + // offset === 0 + frame_dig -3 // offset: uint64 + int 0 + == + bz *if0_end + + // *if0_consequent + // contracts/algo-did.algo.ts:105 + // this.dataBoxes(boxIndex).create(boxIndex === metadata.end ? metadata.endSize : MAX_BOX_SIZE) + frame_dig -2 // boxIndex: uint64 + itob + frame_dig -2 // boxIndex: uint64 + frame_dig -1 // pubKey: Address + int 8 // headOffset + int 8 + box_extract + btoi + == + bz *ternary0_false + frame_dig -1 // pubKey: Address + int 17 // headOffset + int 8 + box_extract + btoi + b *ternary0_end + +*ternary0_false: + int 32768 + +*ternary0_end: + box_create + pop + +*if0_end: + // contracts/algo-did.algo.ts:108 + // this.dataBoxes(boxIndex).replace(offset, data) + frame_dig -2 // boxIndex: uint64 + itob + frame_dig -3 // offset: uint64 + frame_dig -4 // data: bytes + box_replace + retsub + +// finishUpload(address)void +*abi_route_finishUpload: + // pubKey: address + txna ApplicationArgs 1 + dup + len + int 32 + == + + // argument 0 (pubKey) for finishUpload must be a address + assert + + // execute finishUpload(address)void + callsub finishUpload + int 1 + return + +// finishUpload(pubKey: Address): void +// +// +// Mark uploading as false +// +// @param pubKey The address of the DID +finishUpload: + proto 1 0 + + // contracts/algo-did.algo.ts:118 + // assert(this.txn.sender === globals.creatorAddress) + txn Sender + global CreatorAddress + == + assert + + // contracts/algo-did.algo.ts:120 + // this.metadata(pubKey).value.status = READY + frame_dig -1 // pubKey: Address + int 16 // headOffset + byte 0x01 + box_replace + retsub + +// startDelete(address)void +*abi_route_startDelete: + // pubKey: address + txna ApplicationArgs 1 + dup + len + int 32 + == + + // argument 0 (pubKey) for startDelete must be a address + assert + + // execute startDelete(address)void + callsub startDelete + int 1 + return + +// startDelete(pubKey: Address): void +// +// Starts the deletion process for the data associated with a DID +// +// @param pubKey The address of the DID +startDelete: + proto 1 0 + + // Push empty bytes after the frame pointer to reserve space for local variables + byte 0x + + // contracts/algo-did.algo.ts:129 + // assert(this.txn.sender === globals.creatorAddress) + txn Sender + global CreatorAddress + == + assert + + // contracts/algo-did.algo.ts:131 + // metadata = this.metadata(pubKey).value + frame_dig -1 // pubKey: Address + frame_bury 0 // storage key//metadata + + // contracts/algo-did.algo.ts:132 + // assert(metadata.status === READY) + frame_dig -1 // pubKey: Address + int 16 // headOffset + int 1 + box_extract + btoi + int 1 + == + assert + + // contracts/algo-did.algo.ts:134 + // metadata.status = DELETING + frame_dig 0 // storage key//metadata + int 16 // headOffset + byte 0x02 + box_replace + retsub + +// deleteData(address,uint64)void +*abi_route_deleteData: + // boxIndex: uint64 + txna ApplicationArgs 2 + btoi + + // pubKey: address + txna ApplicationArgs 1 + dup + len + int 32 + == + + // argument 1 (pubKey) for deleteData must be a address + assert + + // execute deleteData(address,uint64)void + callsub deleteData + int 1 + return + +// deleteData(pubKey: Address, boxIndex: uint64): void +// +// Deletes a box of data +// +// @param pubKey The address of the DID +// @param boxIndex The index of the box to delete +deleteData: + proto 2 0 + + // Push empty bytes after the frame pointer to reserve space for local variables + byte 0x + dup + + // contracts/algo-did.algo.ts:144 + // assert(this.txn.sender === globals.creatorAddress) + txn Sender + global CreatorAddress + == + assert + + // contracts/algo-did.algo.ts:146 + // metadata = this.metadata(pubKey).value + frame_dig -1 // pubKey: Address + frame_bury 0 // storage key//metadata + + // contracts/algo-did.algo.ts:147 + // assert(metadata.status === DELETING) + frame_dig -1 // pubKey: Address + int 16 // headOffset + int 1 + box_extract + btoi + int 2 + == + assert + + // contracts/algo-did.algo.ts:148 + // assert(metadata.start <= boxIndex && boxIndex <= metadata.end) + frame_dig -1 // pubKey: Address + int 0 + int 8 + box_extract + btoi + frame_dig -2 // boxIndex: uint64 + <= + dup + bz *skip_and1 + frame_dig -2 // boxIndex: uint64 + frame_dig -1 // pubKey: Address + int 8 // headOffset + int 8 + box_extract + btoi + <= + && + +*skip_and1: + assert + + // *if1_condition + // contracts/algo-did.algo.ts:150 + // boxIndex !== metadata.start + frame_dig -2 // boxIndex: uint64 + frame_dig -1 // pubKey: Address + int 0 + int 8 + box_extract + btoi + != + bz *if1_end + + // *if1_consequent + // contracts/algo-did.algo.ts:150 + // assert(metadata.lastDeleted === boxIndex - 1) + frame_dig -1 // pubKey: Address + int 25 // headOffset + int 8 + box_extract + btoi + frame_dig -2 // boxIndex: uint64 + int 1 + - + == + assert + +*if1_end: + // contracts/algo-did.algo.ts:152 + // preMBR = globals.currentApplicationAddress.minBalance + global CurrentApplicationAddress + acct_params_get AcctMinBalance + pop + frame_bury 1 // preMBR: uint64 + + // contracts/algo-did.algo.ts:154 + // this.dataBoxes(boxIndex).delete() + frame_dig -2 // boxIndex: uint64 + itob + box_del + + // *if2_condition + // contracts/algo-did.algo.ts:156 + // boxIndex === metadata.end + frame_dig -2 // boxIndex: uint64 + frame_dig -1 // pubKey: Address + int 8 // headOffset + int 8 + box_extract + btoi + == + bz *if2_else + + // *if2_consequent + // contracts/algo-did.algo.ts:156 + // this.metadata(pubKey).delete() + frame_dig -1 // pubKey: Address + box_del + b *if2_end + +*if2_else: + // contracts/algo-did.algo.ts:157 + // metadata.lastDeleted = boxIndex + int 25 // headOffset + frame_dig -2 // boxIndex: uint64 + itob + frame_dig 0 // storage key//metadata + cover 2 + box_replace + +*if2_end: + // contracts/algo-did.algo.ts:159 + // sendPayment({ + // amount: preMBR - globals.currentApplicationAddress.minBalance, + // receiver: this.txn.sender, + // }) + itxn_begin + int pay + itxn_field TypeEnum + + // contracts/algo-did.algo.ts:160 + // amount: preMBR - globals.currentApplicationAddress.minBalance + frame_dig 1 // preMBR: uint64 + global CurrentApplicationAddress + acct_params_get AcctMinBalance + pop + - + itxn_field Amount + + // contracts/algo-did.algo.ts:161 + // receiver: this.txn.sender + txn Sender + itxn_field Receiver + + // Fee field not set, defaulting to 0 + int 0 + itxn_field Fee + + // Submit inner transaction + itxn_submit + retsub + +// updateApplication()void +*abi_route_updateApplication: + // execute updateApplication()void + callsub updateApplication + int 1 + return + +// updateApplication(): void +// +// Allow the contract to be updated by the creator +updateApplication: + proto 0 0 + + // contracts/algo-did.algo.ts:169 + // assert(this.txn.sender === globals.creatorAddress) + txn Sender + global CreatorAddress + == + assert + retsub + +// dummy()void +*abi_route_dummy: + // execute dummy()void + callsub dummy + int 1 + return + +// dummy(): void +// +// Dummy function to add extra box references for deleteData. +// Boxes are 32k, but a single app call can only inlcude enough references to read/write 8k +// at a time. Thus when a box is deleted, we need to add additional dummy calls with box +// references to increase the total read/write budget to 32k. +dummy: + proto 0 0 + retsub + +*abi_route_createApplication: + int 1 + return + +*create_NoOp: + method "createApplication()void" + txna ApplicationArgs 0 + match *abi_route_createApplication + + // this contract does not implement the given ABI method for create NoOp + err + +*call_NoOp: + method "startUpload(address,uint64,uint64,pay)void" + method "upload(address,uint64,uint64,byte[])void" + method "finishUpload(address)void" + method "startDelete(address)void" + method "deleteData(address,uint64)void" + method "dummy()void" + txna ApplicationArgs 0 + match *abi_route_startUpload *abi_route_upload *abi_route_finishUpload *abi_route_startDelete *abi_route_deleteData *abi_route_dummy + + // this contract does not implement the given ABI method for call NoOp + err + +*call_UpdateApplication: + method "updateApplication()void" + txna ApplicationArgs 0 + match *abi_route_updateApplication + + // this contract does not implement the given ABI method for call UpdateApplication + err \ No newline at end of file diff --git a/reference_contract/contracts/artifacts/AlgoDID.arc32.json b/reference_contract/contracts/artifacts/AlgoDID.arc32.json new file mode 100644 index 0000000..9d43dc9 --- /dev/null +++ b/reference_contract/contracts/artifacts/AlgoDID.arc32.json @@ -0,0 +1,214 @@ +{ + "hints": { + "startUpload(address,uint64,uint64,pay)void": { + "call_config": { + "no_op": "CALL" + } + }, + "upload(address,uint64,uint64,byte[])void": { + "call_config": { + "no_op": "CALL" + } + }, + "finishUpload(address)void": { + "call_config": { + "no_op": "CALL" + } + }, + "startDelete(address)void": { + "call_config": { + "no_op": "CALL" + } + }, + "deleteData(address,uint64)void": { + "call_config": { + "no_op": "CALL" + } + }, + "updateApplication()void": { + "call_config": { + "update_application": "CALL" + } + }, + "dummy()void": { + "call_config": { + "no_op": "CALL" + } + }, + "createApplication()void": { + "call_config": { + "no_op": "CREATE" + } + } + }, + "bare_call_config": { + "no_op": "NEVER", + "opt_in": "NEVER", + "close_out": "NEVER", + "update_application": "NEVER", + "delete_application": "NEVER" + }, + "schema": { + "local": { + "declared": {}, + "reserved": {} + }, + "global": { + "declared": { + "currentIndex": { + "type": "uint64", + "key": "currentIndex" + } + }, + "reserved": {} + } + }, + "state": { + "global": { + "num_byte_slices": 0, + "num_uints": 1 + }, + "local": { + "num_byte_slices": 0, + "num_uints": 0 + } + }, + "source": { + "approval": "#pragma version 10

// This TEAL was generated by TEALScript v0.96.0
// https://github.com/algorandfoundation/TEALScript

// This contract is compliant with and/or implements the following ARCs: [ ARC4 ]

// The following ten lines of TEAL handle initial program flow
// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed
// Here, action refers to the OnComplete in combination with whether the app is being created or called
// Every possible action for this contract is represented in the switch statement
// If the action is not implemented in the contract, its respective branch will be "*NOT_IMPLEMENTED" which just contains "err"
txn ApplicationID
!
int 6
*
txn OnCompletion
+
switch *call_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *call_UpdateApplication *NOT_IMPLEMENTED *create_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED

*NOT_IMPLEMENTED:
	// The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?
	err

// startUpload(address,uint64,uint64,pay)void
*abi_route_startUpload:
	// mbrPayment: pay
	txn GroupIndex
	int 1
	-
	dup
	gtxns TypeEnum
	int pay
	==

	// argument 0 (mbrPayment) for startUpload must be a pay transaction
	assert

	// endBoxSize: uint64
	txna ApplicationArgs 3
	btoi

	// numBoxes: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 3 (pubKey) for startUpload must be a address
	assert

	// execute startUpload(address,uint64,uint64,pay)void
	callsub startUpload
	int 1
	return

// startUpload(pubKey: Address, numBoxes: uint64, endBoxSize: uint64, mbrPayment: PayTxn): void
//
//
// Allocate boxes to begin data upload process
//
// @param pubKey The pubkey of the DID
// @param numBoxes The number of boxes that the data will take up
// @param endBoxSize The size of the last box
// @param mbrPayment Payment from the uploader to cover the box MBR
startUpload:
	proto 4 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x
	dupn 3

	// contracts/algo-did.algo.ts:63
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:65
	// startBox = this.currentIndex.value
	byte 0x63757272656e74496e646578 // "currentIndex"
	app_global_get
	frame_bury 0 // startBox: uint64

	// contracts/algo-did.algo.ts:66
	// endBox = startBox + numBoxes - 1
	frame_dig 0 // startBox: uint64
	frame_dig -2 // numBoxes: uint64
	+
	int 1
	-
	frame_bury 1 // endBox: uint64

	// contracts/algo-did.algo.ts:68
	// metadata: Metadata = {
	//       start: startBox, end: endBox, status: UPLOADING, endSize: endBoxSize, lastDeleted: 0,
	//     }
	frame_dig 0 // startBox: uint64
	itob
	frame_dig 1 // endBox: uint64
	itob
	concat
	byte 0x00
	concat
	frame_dig -3 // endBoxSize: uint64
	itob
	concat
	byte 0x0000000000000000
	concat
	frame_bury 2 // metadata: Metadata

	// contracts/algo-did.algo.ts:72
	// assert(!this.metadata(pubKey).exists)
	frame_dig -1 // pubKey: Address
	box_len
	swap
	pop
	!
	assert

	// contracts/algo-did.algo.ts:74
	// this.metadata(pubKey).value = metadata
	frame_dig -1 // pubKey: Address
	frame_dig 2 // metadata: Metadata
	box_put

	// contracts/algo-did.algo.ts:76
	// this.currentIndex.value = endBox + 1
	byte 0x63757272656e74496e646578 // "currentIndex"
	frame_dig 1 // endBox: uint64
	int 1
	+
	app_global_put

	// contracts/algo-did.algo.ts:78
	// totalCost = numBoxes * COST_PER_BOX // cost of data boxes
	//     + (numBoxes - 1) * MAX_BOX_SIZE * COST_PER_BYTE // cost of data
	//     + numBoxes * 8 * COST_PER_BYTE // cost of data keys
	//     + endBoxSize * COST_PER_BYTE // cost of last data box
	//     + COST_PER_BOX + (8 + 8 + 1 + 8 + 32 + 8) * COST_PER_BYTE
	frame_dig -2 // numBoxes: uint64
	int 2500
	*
	frame_dig -2 // numBoxes: uint64
	int 1
	-
	int 32768
	*
	int 400
	*
	+
	frame_dig -2 // numBoxes: uint64
	int 8
	*
	int 400
	*
	+
	frame_dig -3 // endBoxSize: uint64
	int 400
	*
	+
	int 2500
	+
	int 26000
	+
	frame_bury 3 // totalCost: uint64

	// contracts/algo-did.algo.ts:84
	// assert(mbrPayment.amount === totalCost)
	frame_dig -4 // mbrPayment: PayTxn
	gtxns Amount
	frame_dig 3 // totalCost: uint64
	==
	assert

	// contracts/algo-did.algo.ts:85
	// assert(mbrPayment.receiver === this.app.address)
	frame_dig -4 // mbrPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==
	assert
	retsub

// upload(address,uint64,uint64,byte[])void
*abi_route_upload:
	// data: byte[]
	txna ApplicationArgs 4
	extract 2 0

	// offset: uint64
	txna ApplicationArgs 3
	btoi

	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 3 (pubKey) for upload must be a address
	assert

	// execute upload(address,uint64,uint64,byte[])void
	callsub upload
	int 1
	return

// upload(pubKey: Address, boxIndex: uint64, offset: uint64, data: bytes): void
//
//
// Upload data to a specific offset in a box
//
// @param pubKey The pubkey of the DID
// @param boxIndex The index of the box to upload the given chunk of data to
// @param offset The offset within the box to start writing the data
// @param data The data to write
upload:
	proto 4 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x

	// contracts/algo-did.algo.ts:98
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:100
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: Address
	frame_bury 0 // storage key//metadata

	// contracts/algo-did.algo.ts:101
	// assert(metadata.status === UPLOADING)
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	int 1
	box_extract
	btoi
	int 0
	==
	assert

	// contracts/algo-did.algo.ts:102
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -1 // pubKey: Address
	int 0
	int 8
	box_extract
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz *skip_and0
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	<=
	&&

*skip_and0:
	assert

	// *if0_condition
	// contracts/algo-did.algo.ts:104
	// offset === 0
	frame_dig -3 // offset: uint64
	int 0
	==
	bz *if0_end

	// *if0_consequent
	// contracts/algo-did.algo.ts:105
	// this.dataBoxes(boxIndex).create(boxIndex === metadata.end ? metadata.endSize : MAX_BOX_SIZE)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	==
	bz *ternary0_false
	frame_dig -1 // pubKey: Address
	int 17 // headOffset
	int 8
	box_extract
	btoi
	b *ternary0_end

*ternary0_false:
	int 32768

*ternary0_end:
	box_create
	pop

*if0_end:
	// contracts/algo-did.algo.ts:108
	// this.dataBoxes(boxIndex).replace(offset, data)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -3 // offset: uint64
	frame_dig -4 // data: bytes
	box_replace
	retsub

// finishUpload(address)void
*abi_route_finishUpload:
	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 0 (pubKey) for finishUpload must be a address
	assert

	// execute finishUpload(address)void
	callsub finishUpload
	int 1
	return

// finishUpload(pubKey: Address): void
//
//
// Mark uploading as false
//
// @param pubKey The address of the DID
finishUpload:
	proto 1 0

	// contracts/algo-did.algo.ts:118
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:120
	// this.metadata(pubKey).value.status = READY
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	byte 0x01
	box_replace
	retsub

// startDelete(address)void
*abi_route_startDelete:
	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 0 (pubKey) for startDelete must be a address
	assert

	// execute startDelete(address)void
	callsub startDelete
	int 1
	return

// startDelete(pubKey: Address): void
//
// Starts the deletion process for the data associated with a DID
//
// @param pubKey The address of the DID
startDelete:
	proto 1 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x

	// contracts/algo-did.algo.ts:129
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:131
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: Address
	frame_bury 0 // storage key//metadata

	// contracts/algo-did.algo.ts:132
	// assert(metadata.status === READY)
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	int 1
	box_extract
	btoi
	int 1
	==
	assert

	// contracts/algo-did.algo.ts:134
	// metadata.status = DELETING
	frame_dig 0 // storage key//metadata
	int 16 // headOffset
	byte 0x02
	box_replace
	retsub

// deleteData(address,uint64)void
*abi_route_deleteData:
	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 1 (pubKey) for deleteData must be a address
	assert

	// execute deleteData(address,uint64)void
	callsub deleteData
	int 1
	return

// deleteData(pubKey: Address, boxIndex: uint64): void
//
// Deletes a box of data
//
// @param pubKey The address of the DID
// @param boxIndex The index of the box to delete
deleteData:
	proto 2 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x
	dup

	// contracts/algo-did.algo.ts:144
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:146
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: Address
	frame_bury 0 // storage key//metadata

	// contracts/algo-did.algo.ts:147
	// assert(metadata.status === DELETING)
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	int 1
	box_extract
	btoi
	int 2
	==
	assert

	// contracts/algo-did.algo.ts:148
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -1 // pubKey: Address
	int 0
	int 8
	box_extract
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz *skip_and1
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	<=
	&&

*skip_and1:
	assert

	// *if1_condition
	// contracts/algo-did.algo.ts:150
	// boxIndex !== metadata.start
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 0
	int 8
	box_extract
	btoi
	!=
	bz *if1_end

	// *if1_consequent
	// contracts/algo-did.algo.ts:150
	// assert(metadata.lastDeleted === boxIndex - 1)
	frame_dig -1 // pubKey: Address
	int 25 // headOffset
	int 8
	box_extract
	btoi
	frame_dig -2 // boxIndex: uint64
	int 1
	-
	==
	assert

*if1_end:
	// contracts/algo-did.algo.ts:152
	// preMBR = globals.currentApplicationAddress.minBalance
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	pop
	frame_bury 1 // preMBR: uint64

	// contracts/algo-did.algo.ts:154
	// this.dataBoxes(boxIndex).delete()
	frame_dig -2 // boxIndex: uint64
	itob
	box_del

	// *if2_condition
	// contracts/algo-did.algo.ts:156
	// boxIndex === metadata.end
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	==
	bz *if2_else

	// *if2_consequent
	// contracts/algo-did.algo.ts:156
	// this.metadata(pubKey).delete()
	frame_dig -1 // pubKey: Address
	box_del
	b *if2_end

*if2_else:
	// contracts/algo-did.algo.ts:157
	// metadata.lastDeleted = boxIndex
	int 25 // headOffset
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig 0 // storage key//metadata
	cover 2
	box_replace

*if2_end:
	// contracts/algo-did.algo.ts:159
	// sendPayment({
	//       amount: preMBR - globals.currentApplicationAddress.minBalance,
	//       receiver: this.txn.sender,
	//     })
	itxn_begin
	int pay
	itxn_field TypeEnum

	// contracts/algo-did.algo.ts:160
	// amount: preMBR - globals.currentApplicationAddress.minBalance
	frame_dig 1 // preMBR: uint64
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	pop
	-
	itxn_field Amount

	// contracts/algo-did.algo.ts:161
	// receiver: this.txn.sender
	txn Sender
	itxn_field Receiver

	// Fee field not set, defaulting to 0
	int 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// updateApplication()void
*abi_route_updateApplication:
	// execute updateApplication()void
	callsub updateApplication
	int 1
	return

// updateApplication(): void
//
// Allow the contract to be updated by the creator
updateApplication:
	proto 0 0

	// contracts/algo-did.algo.ts:169
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert
	retsub

// dummy()void
*abi_route_dummy:
	// execute dummy()void
	callsub dummy
	int 1
	return

// dummy(): void
//
// Dummy function to add extra box references for deleteData.
// Boxes are 32k, but a single app call can only inlcude enough references to read/write 8k
// at a time. Thus when a box is deleted, we need to add additional dummy calls with box
// references to increase the total read/write budget to 32k.
dummy:
	proto 0 0
	retsub

*abi_route_createApplication:
	int 1
	return

*create_NoOp:
	method "createApplication()void"
	txna ApplicationArgs 0
	match *abi_route_createApplication

	// this contract does not implement the given ABI method for create NoOp
	err

*call_NoOp:
	method "startUpload(address,uint64,uint64,pay)void"
	method "upload(address,uint64,uint64,byte[])void"
	method "finishUpload(address)void"
	method "startDelete(address)void"
	method "deleteData(address,uint64)void"
	method "dummy()void"
	txna ApplicationArgs 0
	match *abi_route_startUpload *abi_route_upload *abi_route_finishUpload *abi_route_startDelete *abi_route_deleteData *abi_route_dummy

	// this contract does not implement the given ABI method for call NoOp
	err

*call_UpdateApplication:
	method "updateApplication()void"
	txna ApplicationArgs 0
	match *abi_route_updateApplication

	// this contract does not implement the given ABI method for call UpdateApplication
	err", + "clear": "I3ByYWdtYSB2ZXJzaW9uIDEw" + }, + "contract": { + "name": "AlgoDID", + "desc": "", + "methods": [ + { + "name": "startUpload", + "desc": "Allocate boxes to begin data upload process", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The pubkey of the DID" + }, + { + "name": "numBoxes", + "type": "uint64", + "desc": "The number of boxes that the data will take up" + }, + { + "name": "endBoxSize", + "type": "uint64", + "desc": "The size of the last box" + }, + { + "name": "mbrPayment", + "type": "pay", + "desc": "Payment from the uploader to cover the box MBR" + } + ], + "returns": { + "type": "void" + } + }, + { + "name": "upload", + "desc": "Upload data to a specific offset in a box", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The pubkey of the DID" + }, + { + "name": "boxIndex", + "type": "uint64", + "desc": "The index of the box to upload the given chunk of data to" + }, + { + "name": "offset", + "type": "uint64", + "desc": "The offset within the box to start writing the data" + }, + { + "name": "data", + "type": "byte[]", + "desc": "The data to write" + } + ], + "returns": { + "type": "void" + } + }, + { + "name": "finishUpload", + "desc": "Mark uploading as false", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + } + ], + "returns": { + "type": "void" + } + }, + { + "name": "startDelete", + "desc": "Starts the deletion process for the data associated with a DID", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + } + ], + "returns": { + "type": "void" + } + }, + { + "name": "deleteData", + "desc": "Deletes a box of data", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + }, + { + "name": "boxIndex", + "type": "uint64", + "desc": "The index of the box to delete" + } + ], + "returns": { + "type": "void" + } + }, + { + "name": "updateApplication", + "desc": "Allow the contract to be updated by the creator", + "args": [], + "returns": { + "type": "void" + } + }, + { + "name": "dummy", + "desc": "Dummy function to add extra box references for deleteData.Boxes are 32k, but a single app call can only inlcude enough references to read/write 8kat a time. Thus when a box is deleted, we need to add additional dummy calls with boxreferences to increase the total read/write budget to 32k.", + "args": [], + "returns": { + "type": "void" + } + }, + { + "name": "createApplication", + "args": [], + "returns": { + "type": "void" + } + } + ] + } +} \ No newline at end of file diff --git a/reference_contract/contracts/artifacts/AlgoDID.arc4.json b/reference_contract/contracts/artifacts/AlgoDID.arc4.json new file mode 100644 index 0000000..59184cc --- /dev/null +++ b/reference_contract/contracts/artifacts/AlgoDID.arc4.json @@ -0,0 +1,134 @@ +{ + "name": "AlgoDID", + "desc": "", + "methods": [ + { + "name": "startUpload", + "desc": "Allocate boxes to begin data upload process", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The pubkey of the DID" + }, + { + "name": "numBoxes", + "type": "uint64", + "desc": "The number of boxes that the data will take up" + }, + { + "name": "endBoxSize", + "type": "uint64", + "desc": "The size of the last box" + }, + { + "name": "mbrPayment", + "type": "pay", + "desc": "Payment from the uploader to cover the box MBR" + } + ], + "returns": { + "type": "void" + } + }, + { + "name": "upload", + "desc": "Upload data to a specific offset in a box", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The pubkey of the DID" + }, + { + "name": "boxIndex", + "type": "uint64", + "desc": "The index of the box to upload the given chunk of data to" + }, + { + "name": "offset", + "type": "uint64", + "desc": "The offset within the box to start writing the data" + }, + { + "name": "data", + "type": "byte[]", + "desc": "The data to write" + } + ], + "returns": { + "type": "void" + } + }, + { + "name": "finishUpload", + "desc": "Mark uploading as false", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + } + ], + "returns": { + "type": "void" + } + }, + { + "name": "startDelete", + "desc": "Starts the deletion process for the data associated with a DID", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + } + ], + "returns": { + "type": "void" + } + }, + { + "name": "deleteData", + "desc": "Deletes a box of data", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + }, + { + "name": "boxIndex", + "type": "uint64", + "desc": "The index of the box to delete" + } + ], + "returns": { + "type": "void" + } + }, + { + "name": "updateApplication", + "desc": "Allow the contract to be updated by the creator", + "args": [], + "returns": { + "type": "void" + } + }, + { + "name": "dummy", + "desc": "Dummy function to add extra box references for deleteData.Boxes are 32k, but a single app call can only inlcude enough references to read/write 8kat a time. Thus when a box is deleted, we need to add additional dummy calls with boxreferences to increase the total read/write budget to 32k.", + "args": [], + "returns": { + "type": "void" + } + }, + { + "name": "createApplication", + "args": [], + "returns": { + "type": "void" + } + } + ] +} \ No newline at end of file diff --git a/reference_contract/contracts/artifacts/AlgoDID.arc56_draft.json b/reference_contract/contracts/artifacts/AlgoDID.arc56_draft.json new file mode 100644 index 0000000..497ad1a --- /dev/null +++ b/reference_contract/contracts/artifacts/AlgoDID.arc56_draft.json @@ -0,0 +1,3189 @@ +{ + "name": "AlgoDID", + "desc": "", + "methods": [ + { + "name": "startUpload", + "desc": "Allocate boxes to begin data upload process", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The pubkey of the DID" + }, + { + "name": "numBoxes", + "type": "uint64", + "desc": "The number of boxes that the data will take up" + }, + { + "name": "endBoxSize", + "type": "uint64", + "desc": "The size of the last box" + }, + { + "name": "mbrPayment", + "type": "pay", + "desc": "Payment from the uploader to cover the box MBR" + } + ], + "returns": { + "type": "void" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + } + }, + { + "name": "upload", + "desc": "Upload data to a specific offset in a box", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The pubkey of the DID" + }, + { + "name": "boxIndex", + "type": "uint64", + "desc": "The index of the box to upload the given chunk of data to" + }, + { + "name": "offset", + "type": "uint64", + "desc": "The offset within the box to start writing the data" + }, + { + "name": "data", + "type": "byte[]", + "desc": "The data to write" + } + ], + "returns": { + "type": "void" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + } + }, + { + "name": "finishUpload", + "desc": "Mark uploading as false", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + } + ], + "returns": { + "type": "void" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + } + }, + { + "name": "startDelete", + "desc": "Starts the deletion process for the data associated with a DID", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + } + ], + "returns": { + "type": "void" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + } + }, + { + "name": "deleteData", + "desc": "Deletes a box of data", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + }, + { + "name": "boxIndex", + "type": "uint64", + "desc": "The index of the box to delete" + } + ], + "returns": { + "type": "void" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + } + }, + { + "name": "updateApplication", + "desc": "Allow the contract to be updated by the creator", + "args": [], + "returns": { + "type": "void" + }, + "actions": { + "create": [], + "call": [ + "UpdateApplication" + ] + } + }, + { + "name": "dummy", + "desc": "Dummy function to add extra box references for deleteData.Boxes are 32k, but a single app call can only inlcude enough references to read/write 8kat a time. Thus when a box is deleted, we need to add additional dummy calls with boxreferences to increase the total read/write budget to 32k.", + "args": [], + "returns": { + "type": "void" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + } + }, + { + "name": "createApplication", + "args": [], + "returns": { + "type": "void" + }, + "actions": { + "create": [ + "NoOp" + ], + "call": [] + } + } + ], + "arcs": [ + 4, + 56 + ], + "structs": { + "Metadata": { + "start": "uint64", + "end": "uint64", + "status": "uint8", + "endSize": "uint64", + "lastDeleted": "uint64" + } + }, + "state": { + "schema": { + "global": { + "bytes": 0, + "ints": 1 + }, + "local": { + "bytes": 0, + "ints": 0 + } + }, + "keys": { + "global": { + "currentIndex": { + "key": "Y3VycmVudEluZGV4", + "keyType": "bytes", + "valueType": "uint64" + } + }, + "local": {}, + "box": {} + }, + "maps": { + "global": {}, + "local": {}, + "box": { + "dataBoxes": { + "keyType": "uint64", + "valueType": "bytes" + }, + "metadata": { + "keyType": "address", + "valueType": "Metadata" + } + } + } + }, + "bareActions": { + "create": [], + "call": [] + }, + "sourceInfo": [ + { + "teal": 1, + "source": 38, + "pc": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31 + ] + }, + { + "teal": 13, + "source": 38, + "pc": [ + 32, + 33 + ] + }, + { + "teal": 14, + "source": 38, + "pc": [ + 34 + ] + }, + { + "teal": 15, + "source": 38, + "pc": [ + 35, + 36 + ] + }, + { + "teal": 16, + "source": 38, + "pc": [ + 37 + ] + }, + { + "teal": 17, + "source": 38, + "pc": [ + 38, + 39 + ] + }, + { + "teal": 18, + "source": 38, + "pc": [ + 40 + ] + }, + { + "teal": 19, + "source": 38, + "pc": [ + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66 + ] + }, + { + "teal": 23, + "source": 38, + "errorMessage": "The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?", + "pc": [ + 67 + ] + }, + { + "teal": 28, + "source": 61, + "pc": [ + 68, + 69 + ] + }, + { + "teal": 29, + "source": 61, + "pc": [ + 70 + ] + }, + { + "teal": 30, + "source": 61, + "pc": [ + 71 + ] + }, + { + "teal": 31, + "source": 61, + "pc": [ + 72 + ] + }, + { + "teal": 32, + "source": 61, + "pc": [ + 73, + 74 + ] + }, + { + "teal": 33, + "source": 61, + "pc": [ + 75 + ] + }, + { + "teal": 34, + "source": 61, + "pc": [ + 76 + ] + }, + { + "teal": 37, + "source": 61, + "errorMessage": "argument 0 (mbrPayment) for startUpload must be a pay transaction", + "pc": [ + 77 + ] + }, + { + "teal": 40, + "source": 60, + "pc": [ + 78, + 79, + 80 + ] + }, + { + "teal": 41, + "source": 60, + "pc": [ + 81 + ] + }, + { + "teal": 44, + "source": 59, + "pc": [ + 82, + 83, + 84 + ] + }, + { + "teal": 45, + "source": 59, + "pc": [ + 85 + ] + }, + { + "teal": 48, + "source": 58, + "pc": [ + 86, + 87, + 88 + ] + }, + { + "teal": 49, + "source": 58, + "pc": [ + 89 + ] + }, + { + "teal": 50, + "source": 58, + "pc": [ + 90 + ] + }, + { + "teal": 51, + "source": 58, + "pc": [ + 91 + ] + }, + { + "teal": 52, + "source": 58, + "pc": [ + 92 + ] + }, + { + "teal": 55, + "source": 58, + "errorMessage": "argument 3 (pubKey) for startUpload must be a address", + "pc": [ + 93 + ] + }, + { + "teal": 58, + "source": 57, + "pc": [ + 94, + 95, + 96 + ] + }, + { + "teal": 59, + "source": 57, + "pc": [ + 97 + ] + }, + { + "teal": 60, + "source": 57, + "pc": [ + 98 + ] + }, + { + "teal": 72, + "source": 57, + "pc": [ + 99, + 100, + 101 + ] + }, + { + "teal": 75, + "source": 57, + "pc": [ + 102 + ] + }, + { + "teal": 76, + "source": 57, + "pc": [ + 103, + 104 + ] + }, + { + "teal": 80, + "source": 63, + "pc": [ + 105, + 106 + ] + }, + { + "teal": 81, + "source": 63, + "pc": [ + 107, + 108 + ] + }, + { + "teal": 82, + "source": 63, + "pc": [ + 109 + ] + }, + { + "teal": 83, + "source": 63, + "pc": [ + 110 + ] + }, + { + "teal": 87, + "source": 65, + "pc": [ + 111 + ] + }, + { + "teal": 88, + "source": 65, + "pc": [ + 112 + ] + }, + { + "teal": 89, + "source": 65, + "pc": [ + 113, + 114 + ] + }, + { + "teal": 93, + "source": 66, + "pc": [ + 115, + 116 + ] + }, + { + "teal": 94, + "source": 66, + "pc": [ + 117, + 118 + ] + }, + { + "teal": 95, + "source": 66, + "pc": [ + 119 + ] + }, + { + "teal": 96, + "source": 66, + "pc": [ + 120 + ] + }, + { + "teal": 97, + "source": 66, + "pc": [ + 121 + ] + }, + { + "teal": 98, + "source": 66, + "pc": [ + 122, + 123 + ] + }, + { + "teal": 104, + "source": 69, + "pc": [ + 124, + 125 + ] + }, + { + "teal": 105, + "source": 69, + "pc": [ + 126 + ] + }, + { + "teal": 106, + "source": 69, + "pc": [ + 127, + 128 + ] + }, + { + "teal": 107, + "source": 69, + "pc": [ + 129 + ] + }, + { + "teal": 108, + "source": 69, + "pc": [ + 130 + ] + }, + { + "teal": 109, + "source": 69, + "pc": [ + 131, + 132, + 133 + ] + }, + { + "teal": 110, + "source": 69, + "pc": [ + 134 + ] + }, + { + "teal": 111, + "source": 69, + "pc": [ + 135, + 136 + ] + }, + { + "teal": 112, + "source": 69, + "pc": [ + 137 + ] + }, + { + "teal": 113, + "source": 69, + "pc": [ + 138 + ] + }, + { + "teal": 114, + "source": 69, + "pc": [ + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148 + ] + }, + { + "teal": 115, + "source": 69, + "pc": [ + 149 + ] + }, + { + "teal": 116, + "source": 68, + "pc": [ + 150, + 151 + ] + }, + { + "teal": 120, + "source": 72, + "pc": [ + 152, + 153 + ] + }, + { + "teal": 121, + "source": 72, + "pc": [ + 154 + ] + }, + { + "teal": 122, + "source": 72, + "pc": [ + 155 + ] + }, + { + "teal": 123, + "source": 72, + "pc": [ + 156 + ] + }, + { + "teal": 124, + "source": 72, + "pc": [ + 157 + ] + }, + { + "teal": 125, + "source": 72, + "pc": [ + 158 + ] + }, + { + "teal": 129, + "source": 74, + "pc": [ + 159, + 160 + ] + }, + { + "teal": 130, + "source": 74, + "pc": [ + 161, + 162 + ] + }, + { + "teal": 131, + "source": 74, + "pc": [ + 163 + ] + }, + { + "teal": 135, + "source": 76, + "pc": [ + 164 + ] + }, + { + "teal": 136, + "source": 76, + "pc": [ + 165, + 166 + ] + }, + { + "teal": 137, + "source": 76, + "pc": [ + 167 + ] + }, + { + "teal": 138, + "source": 76, + "pc": [ + 168 + ] + }, + { + "teal": 139, + "source": 76, + "pc": [ + 169 + ] + }, + { + "teal": 147, + "source": 78, + "pc": [ + 170, + 171 + ] + }, + { + "teal": 148, + "source": 78, + "pc": [ + 172, + 173 + ] + }, + { + "teal": 149, + "source": 78, + "pc": [ + 174 + ] + }, + { + "teal": 150, + "source": 79, + "pc": [ + 175, + 176 + ] + }, + { + "teal": 151, + "source": 79, + "pc": [ + 177 + ] + }, + { + "teal": 152, + "source": 79, + "pc": [ + 178 + ] + }, + { + "teal": 153, + "source": 79, + "pc": [ + 179, + 180 + ] + }, + { + "teal": 154, + "source": 79, + "pc": [ + 181 + ] + }, + { + "teal": 155, + "source": 79, + "pc": [ + 182, + 183 + ] + }, + { + "teal": 156, + "source": 79, + "pc": [ + 184 + ] + }, + { + "teal": 157, + "source": 79, + "pc": [ + 185 + ] + }, + { + "teal": 158, + "source": 80, + "pc": [ + 186, + 187 + ] + }, + { + "teal": 159, + "source": 80, + "pc": [ + 188 + ] + }, + { + "teal": 160, + "source": 80, + "pc": [ + 189 + ] + }, + { + "teal": 161, + "source": 80, + "pc": [ + 190, + 191 + ] + }, + { + "teal": 162, + "source": 80, + "pc": [ + 192 + ] + }, + { + "teal": 163, + "source": 80, + "pc": [ + 193 + ] + }, + { + "teal": 164, + "source": 81, + "pc": [ + 194, + 195 + ] + }, + { + "teal": 165, + "source": 81, + "pc": [ + 196, + 197 + ] + }, + { + "teal": 166, + "source": 81, + "pc": [ + 198 + ] + }, + { + "teal": 167, + "source": 81, + "pc": [ + 199 + ] + }, + { + "teal": 168, + "source": 82, + "pc": [ + 200, + 201 + ] + }, + { + "teal": 169, + "source": 82, + "pc": [ + 202 + ] + }, + { + "teal": 170, + "source": 82, + "pc": [ + 203, + 204, + 205, + 206 + ] + }, + { + "teal": 171, + "source": 82, + "pc": [ + 207 + ] + }, + { + "teal": 172, + "source": 78, + "pc": [ + 208, + 209 + ] + }, + { + "teal": 176, + "source": 84, + "pc": [ + 210, + 211 + ] + }, + { + "teal": 177, + "source": 84, + "pc": [ + 212, + 213 + ] + }, + { + "teal": 178, + "source": 84, + "pc": [ + 214, + 215 + ] + }, + { + "teal": 179, + "source": 84, + "pc": [ + 216 + ] + }, + { + "teal": 180, + "source": 84, + "pc": [ + 217 + ] + }, + { + "teal": 184, + "source": 85, + "pc": [ + 218, + 219 + ] + }, + { + "teal": 185, + "source": 85, + "pc": [ + 220, + 221 + ] + }, + { + "teal": 186, + "source": 85, + "pc": [ + 222, + 223 + ] + }, + { + "teal": 187, + "source": 85, + "pc": [ + 224 + ] + }, + { + "teal": 188, + "source": 85, + "pc": [ + 225 + ] + }, + { + "teal": 189, + "source": 57, + "pc": [ + 226 + ] + }, + { + "teal": 194, + "source": 97, + "pc": [ + 227, + 228, + 229 + ] + }, + { + "teal": 195, + "source": 97, + "pc": [ + 230, + 231, + 232 + ] + }, + { + "teal": 198, + "source": 97, + "pc": [ + 233, + 234, + 235 + ] + }, + { + "teal": 199, + "source": 97, + "pc": [ + 236 + ] + }, + { + "teal": 202, + "source": 97, + "pc": [ + 237, + 238, + 239 + ] + }, + { + "teal": 203, + "source": 97, + "pc": [ + 240 + ] + }, + { + "teal": 206, + "source": 97, + "pc": [ + 241, + 242, + 243 + ] + }, + { + "teal": 207, + "source": 97, + "pc": [ + 244 + ] + }, + { + "teal": 208, + "source": 97, + "pc": [ + 245 + ] + }, + { + "teal": 209, + "source": 97, + "pc": [ + 246 + ] + }, + { + "teal": 210, + "source": 97, + "pc": [ + 247 + ] + }, + { + "teal": 213, + "source": 97, + "errorMessage": "argument 3 (pubKey) for upload must be a address", + "pc": [ + 248 + ] + }, + { + "teal": 216, + "source": 97, + "pc": [ + 249, + 250, + 251 + ] + }, + { + "teal": 217, + "source": 97, + "pc": [ + 252 + ] + }, + { + "teal": 218, + "source": 97, + "pc": [ + 253 + ] + }, + { + "teal": 230, + "source": 97, + "pc": [ + 254, + 255, + 256 + ] + }, + { + "teal": 233, + "source": 97, + "pc": [ + 257 + ] + }, + { + "teal": 237, + "source": 98, + "pc": [ + 258, + 259 + ] + }, + { + "teal": 238, + "source": 98, + "pc": [ + 260, + 261 + ] + }, + { + "teal": 239, + "source": 98, + "pc": [ + 262 + ] + }, + { + "teal": 240, + "source": 98, + "pc": [ + 263 + ] + }, + { + "teal": 244, + "source": 100, + "pc": [ + 264, + 265 + ] + }, + { + "teal": 245, + "source": 100, + "pc": [ + 266, + 267 + ] + }, + { + "teal": 249, + "source": 100, + "pc": [ + 268, + 269 + ] + }, + { + "teal": 250, + "source": 100, + "pc": [ + 270, + 271 + ] + }, + { + "teal": 251, + "source": 100, + "pc": [ + 272 + ] + }, + { + "teal": 252, + "source": 100, + "pc": [ + 273 + ] + }, + { + "teal": 253, + "source": 101, + "pc": [ + 274 + ] + }, + { + "teal": 254, + "source": 26, + "pc": [ + 275 + ] + }, + { + "teal": 255, + "source": 101, + "pc": [ + 276 + ] + }, + { + "teal": 256, + "source": 101, + "pc": [ + 277 + ] + }, + { + "teal": 260, + "source": 100, + "pc": [ + 278, + 279 + ] + }, + { + "teal": 261, + "source": 100, + "pc": [ + 280 + ] + }, + { + "teal": 262, + "source": 100, + "pc": [ + 281 + ] + }, + { + "teal": 263, + "source": 100, + "pc": [ + 282 + ] + }, + { + "teal": 264, + "source": 102, + "pc": [ + 283 + ] + }, + { + "teal": 265, + "source": 102, + "pc": [ + 284, + 285 + ] + }, + { + "teal": 266, + "source": 102, + "pc": [ + 286 + ] + }, + { + "teal": 267, + "source": 102, + "pc": [ + 287 + ] + }, + { + "teal": 268, + "source": 102, + "pc": [ + 288, + 289, + 290 + ] + }, + { + "teal": 269, + "source": 102, + "pc": [ + 291, + 292 + ] + }, + { + "teal": 270, + "source": 100, + "pc": [ + 293, + 294 + ] + }, + { + "teal": 271, + "source": 100, + "pc": [ + 295 + ] + }, + { + "teal": 272, + "source": 100, + "pc": [ + 296 + ] + }, + { + "teal": 273, + "source": 100, + "pc": [ + 297 + ] + }, + { + "teal": 274, + "source": 102, + "pc": [ + 298 + ] + }, + { + "teal": 275, + "source": 102, + "pc": [ + 299 + ] + }, + { + "teal": 276, + "source": 102, + "pc": [ + 300 + ] + }, + { + "teal": 279, + "source": 102, + "pc": [ + 301 + ] + }, + { + "teal": 284, + "source": 104, + "pc": [ + 302, + 303 + ] + }, + { + "teal": 285, + "source": 104, + "pc": [ + 304 + ] + }, + { + "teal": 286, + "source": 104, + "pc": [ + 305 + ] + }, + { + "teal": 287, + "source": 104, + "pc": [ + 306, + 307, + 308 + ] + }, + { + "teal": 292, + "source": 105, + "pc": [ + 309, + 310 + ] + }, + { + "teal": 293, + "source": 105, + "pc": [ + 311 + ] + }, + { + "teal": 294, + "source": 105, + "pc": [ + 312, + 313 + ] + }, + { + "teal": 295, + "source": 100, + "pc": [ + 314, + 315 + ] + }, + { + "teal": 296, + "source": 100, + "pc": [ + 316 + ] + }, + { + "teal": 297, + "source": 100, + "pc": [ + 317 + ] + }, + { + "teal": 298, + "source": 100, + "pc": [ + 318 + ] + }, + { + "teal": 299, + "source": 105, + "pc": [ + 319 + ] + }, + { + "teal": 300, + "source": 105, + "pc": [ + 320 + ] + }, + { + "teal": 301, + "source": 105, + "pc": [ + 321, + 322, + 323 + ] + }, + { + "teal": 302, + "source": 100, + "pc": [ + 324, + 325 + ] + }, + { + "teal": 303, + "source": 100, + "pc": [ + 326, + 327 + ] + }, + { + "teal": 304, + "source": 100, + "pc": [ + 328 + ] + }, + { + "teal": 305, + "source": 100, + "pc": [ + 329 + ] + }, + { + "teal": 306, + "source": 105, + "pc": [ + 330 + ] + }, + { + "teal": 307, + "source": 105, + "pc": [ + 331, + 332, + 333 + ] + }, + { + "teal": 310, + "source": 105, + "pc": [ + 334, + 335 + ] + }, + { + "teal": 313, + "source": 105, + "pc": [ + 336 + ] + }, + { + "teal": 314, + "source": 105, + "pc": [ + 337 + ] + }, + { + "teal": 319, + "source": 108, + "pc": [ + 338, + 339 + ] + }, + { + "teal": 320, + "source": 108, + "pc": [ + 340 + ] + }, + { + "teal": 321, + "source": 108, + "pc": [ + 341, + 342 + ] + }, + { + "teal": 322, + "source": 108, + "pc": [ + 343, + 344 + ] + }, + { + "teal": 323, + "source": 108, + "pc": [ + 345 + ] + }, + { + "teal": 324, + "source": 97, + "pc": [ + 346 + ] + }, + { + "teal": 329, + "source": 117, + "pc": [ + 347, + 348, + 349 + ] + }, + { + "teal": 330, + "source": 117, + "pc": [ + 350 + ] + }, + { + "teal": 331, + "source": 117, + "pc": [ + 351 + ] + }, + { + "teal": 332, + "source": 117, + "pc": [ + 352 + ] + }, + { + "teal": 333, + "source": 117, + "pc": [ + 353 + ] + }, + { + "teal": 336, + "source": 117, + "errorMessage": "argument 0 (pubKey) for finishUpload must be a address", + "pc": [ + 354 + ] + }, + { + "teal": 339, + "source": 117, + "pc": [ + 355, + 356, + 357 + ] + }, + { + "teal": 340, + "source": 117, + "pc": [ + 358 + ] + }, + { + "teal": 341, + "source": 117, + "pc": [ + 359 + ] + }, + { + "teal": 350, + "source": 117, + "pc": [ + 360, + 361, + 362 + ] + }, + { + "teal": 354, + "source": 118, + "pc": [ + 363, + 364 + ] + }, + { + "teal": 355, + "source": 118, + "pc": [ + 365, + 366 + ] + }, + { + "teal": 356, + "source": 118, + "pc": [ + 367 + ] + }, + { + "teal": 357, + "source": 118, + "pc": [ + 368 + ] + }, + { + "teal": 361, + "source": 120, + "pc": [ + 369, + 370 + ] + }, + { + "teal": 362, + "source": 120, + "pc": [ + 371, + 372 + ] + }, + { + "teal": 363, + "source": 120, + "pc": [ + 373, + 374, + 375 + ] + }, + { + "teal": 364, + "source": 120, + "pc": [ + 376 + ] + }, + { + "teal": 365, + "source": 117, + "pc": [ + 377 + ] + }, + { + "teal": 370, + "source": 128, + "pc": [ + 378, + 379, + 380 + ] + }, + { + "teal": 371, + "source": 128, + "pc": [ + 381 + ] + }, + { + "teal": 372, + "source": 128, + "pc": [ + 382 + ] + }, + { + "teal": 373, + "source": 128, + "pc": [ + 383 + ] + }, + { + "teal": 374, + "source": 128, + "pc": [ + 384 + ] + }, + { + "teal": 377, + "source": 128, + "errorMessage": "argument 0 (pubKey) for startDelete must be a address", + "pc": [ + 385 + ] + }, + { + "teal": 380, + "source": 128, + "pc": [ + 386, + 387, + 388 + ] + }, + { + "teal": 381, + "source": 128, + "pc": [ + 389 + ] + }, + { + "teal": 382, + "source": 128, + "pc": [ + 390 + ] + }, + { + "teal": 390, + "source": 128, + "pc": [ + 391, + 392, + 393 + ] + }, + { + "teal": 393, + "source": 128, + "pc": [ + 394 + ] + }, + { + "teal": 397, + "source": 129, + "pc": [ + 395, + 396 + ] + }, + { + "teal": 398, + "source": 129, + "pc": [ + 397, + 398 + ] + }, + { + "teal": 399, + "source": 129, + "pc": [ + 399 + ] + }, + { + "teal": 400, + "source": 129, + "pc": [ + 400 + ] + }, + { + "teal": 404, + "source": 131, + "pc": [ + 401, + 402 + ] + }, + { + "teal": 405, + "source": 131, + "pc": [ + 403, + 404 + ] + }, + { + "teal": 409, + "source": 131, + "pc": [ + 405, + 406 + ] + }, + { + "teal": 410, + "source": 131, + "pc": [ + 407, + 408 + ] + }, + { + "teal": 411, + "source": 131, + "pc": [ + 409 + ] + }, + { + "teal": 412, + "source": 131, + "pc": [ + 410 + ] + }, + { + "teal": 413, + "source": 132, + "pc": [ + 411 + ] + }, + { + "teal": 414, + "source": 29, + "pc": [ + 412 + ] + }, + { + "teal": 415, + "source": 132, + "pc": [ + 413 + ] + }, + { + "teal": 416, + "source": 132, + "pc": [ + 414 + ] + }, + { + "teal": 420, + "source": 131, + "pc": [ + 415, + 416 + ] + }, + { + "teal": 421, + "source": 131, + "pc": [ + 417, + 418 + ] + }, + { + "teal": 422, + "source": 131, + "pc": [ + 419, + 420, + 421 + ] + }, + { + "teal": 423, + "source": 131, + "pc": [ + 422 + ] + }, + { + "teal": 424, + "source": 128, + "pc": [ + 423 + ] + }, + { + "teal": 429, + "source": 143, + "pc": [ + 424, + 425, + 426 + ] + }, + { + "teal": 430, + "source": 143, + "pc": [ + 427 + ] + }, + { + "teal": 433, + "source": 143, + "pc": [ + 428, + 429, + 430 + ] + }, + { + "teal": 434, + "source": 143, + "pc": [ + 431 + ] + }, + { + "teal": 435, + "source": 143, + "pc": [ + 432 + ] + }, + { + "teal": 436, + "source": 143, + "pc": [ + 433 + ] + }, + { + "teal": 437, + "source": 143, + "pc": [ + 434 + ] + }, + { + "teal": 440, + "source": 143, + "errorMessage": "argument 1 (pubKey) for deleteData must be a address", + "pc": [ + 435 + ] + }, + { + "teal": 443, + "source": 143, + "pc": [ + 436, + 437, + 438 + ] + }, + { + "teal": 444, + "source": 143, + "pc": [ + 439 + ] + }, + { + "teal": 445, + "source": 143, + "pc": [ + 440 + ] + }, + { + "teal": 454, + "source": 143, + "pc": [ + 441, + 442, + 443 + ] + }, + { + "teal": 457, + "source": 143, + "pc": [ + 444 + ] + }, + { + "teal": 458, + "source": 143, + "pc": [ + 445 + ] + }, + { + "teal": 462, + "source": 144, + "pc": [ + 446, + 447 + ] + }, + { + "teal": 463, + "source": 144, + "pc": [ + 448, + 449 + ] + }, + { + "teal": 464, + "source": 144, + "pc": [ + 450 + ] + }, + { + "teal": 465, + "source": 144, + "pc": [ + 451 + ] + }, + { + "teal": 469, + "source": 146, + "pc": [ + 452, + 453 + ] + }, + { + "teal": 470, + "source": 146, + "pc": [ + 454, + 455 + ] + }, + { + "teal": 474, + "source": 146, + "pc": [ + 456, + 457 + ] + }, + { + "teal": 475, + "source": 146, + "pc": [ + 458, + 459 + ] + }, + { + "teal": 476, + "source": 146, + "pc": [ + 460 + ] + }, + { + "teal": 477, + "source": 146, + "pc": [ + 461 + ] + }, + { + "teal": 478, + "source": 147, + "pc": [ + 462 + ] + }, + { + "teal": 479, + "source": 32, + "pc": [ + 463, + 464 + ] + }, + { + "teal": 480, + "source": 147, + "pc": [ + 465 + ] + }, + { + "teal": 481, + "source": 147, + "pc": [ + 466 + ] + }, + { + "teal": 485, + "source": 146, + "pc": [ + 467, + 468 + ] + }, + { + "teal": 486, + "source": 146, + "pc": [ + 469 + ] + }, + { + "teal": 487, + "source": 146, + "pc": [ + 470 + ] + }, + { + "teal": 488, + "source": 146, + "pc": [ + 471 + ] + }, + { + "teal": 489, + "source": 148, + "pc": [ + 472 + ] + }, + { + "teal": 490, + "source": 148, + "pc": [ + 473, + 474 + ] + }, + { + "teal": 491, + "source": 148, + "pc": [ + 475 + ] + }, + { + "teal": 492, + "source": 148, + "pc": [ + 476 + ] + }, + { + "teal": 493, + "source": 148, + "pc": [ + 477, + 478, + 479 + ] + }, + { + "teal": 494, + "source": 148, + "pc": [ + 480, + 481 + ] + }, + { + "teal": 495, + "source": 146, + "pc": [ + 482, + 483 + ] + }, + { + "teal": 496, + "source": 146, + "pc": [ + 484 + ] + }, + { + "teal": 497, + "source": 146, + "pc": [ + 485 + ] + }, + { + "teal": 498, + "source": 146, + "pc": [ + 486 + ] + }, + { + "teal": 499, + "source": 148, + "pc": [ + 487 + ] + }, + { + "teal": 500, + "source": 148, + "pc": [ + 488 + ] + }, + { + "teal": 501, + "source": 148, + "pc": [ + 489 + ] + }, + { + "teal": 504, + "source": 148, + "pc": [ + 490 + ] + }, + { + "teal": 509, + "source": 150, + "pc": [ + 491, + 492 + ] + }, + { + "teal": 510, + "source": 146, + "pc": [ + 493, + 494 + ] + }, + { + "teal": 511, + "source": 146, + "pc": [ + 495 + ] + }, + { + "teal": 512, + "source": 146, + "pc": [ + 496 + ] + }, + { + "teal": 513, + "source": 146, + "pc": [ + 497 + ] + }, + { + "teal": 514, + "source": 150, + "pc": [ + 498 + ] + }, + { + "teal": 515, + "source": 150, + "pc": [ + 499 + ] + }, + { + "teal": 516, + "source": 150, + "pc": [ + 500, + 501, + 502 + ] + }, + { + "teal": 521, + "source": 146, + "pc": [ + 503, + 504 + ] + }, + { + "teal": 522, + "source": 146, + "pc": [ + 505, + 506 + ] + }, + { + "teal": 523, + "source": 146, + "pc": [ + 507 + ] + }, + { + "teal": 524, + "source": 146, + "pc": [ + 508 + ] + }, + { + "teal": 525, + "source": 150, + "pc": [ + 509 + ] + }, + { + "teal": 526, + "source": 150, + "pc": [ + 510, + 511 + ] + }, + { + "teal": 527, + "source": 150, + "pc": [ + 512 + ] + }, + { + "teal": 528, + "source": 150, + "pc": [ + 513 + ] + }, + { + "teal": 529, + "source": 150, + "pc": [ + 514 + ] + }, + { + "teal": 530, + "source": 150, + "pc": [ + 515 + ] + }, + { + "teal": 535, + "source": 152, + "pc": [ + 516, + 517 + ] + }, + { + "teal": 536, + "source": 152, + "pc": [ + 518, + 519 + ] + }, + { + "teal": 537, + "source": 152, + "pc": [ + 520 + ] + }, + { + "teal": 538, + "source": 152, + "pc": [ + 521, + 522 + ] + }, + { + "teal": 542, + "source": 154, + "pc": [ + 523, + 524 + ] + }, + { + "teal": 543, + "source": 154, + "pc": [ + 525 + ] + }, + { + "teal": 544, + "source": 154, + "pc": [ + 526 + ] + }, + { + "teal": 549, + "source": 156, + "pc": [ + 527, + 528 + ] + }, + { + "teal": 550, + "source": 146, + "pc": [ + 529, + 530 + ] + }, + { + "teal": 551, + "source": 146, + "pc": [ + 531 + ] + }, + { + "teal": 552, + "source": 146, + "pc": [ + 532 + ] + }, + { + "teal": 553, + "source": 146, + "pc": [ + 533 + ] + }, + { + "teal": 554, + "source": 156, + "pc": [ + 534 + ] + }, + { + "teal": 555, + "source": 156, + "pc": [ + 535 + ] + }, + { + "teal": 556, + "source": 156, + "pc": [ + 536, + 537, + 538 + ] + }, + { + "teal": 561, + "source": 156, + "pc": [ + 539, + 540 + ] + }, + { + "teal": 562, + "source": 156, + "pc": [ + 541 + ] + }, + { + "teal": 563, + "source": 156, + "pc": [ + 542, + 543, + 544 + ] + }, + { + "teal": 568, + "source": 157, + "pc": [ + 545, + 546 + ] + }, + { + "teal": 569, + "source": 157, + "pc": [ + 547, + 548 + ] + }, + { + "teal": 570, + "source": 157, + "pc": [ + 549 + ] + }, + { + "teal": 571, + "source": 146, + "pc": [ + 550, + 551 + ] + }, + { + "teal": 572, + "source": 146, + "pc": [ + 552, + 553 + ] + }, + { + "teal": 573, + "source": 146, + "pc": [ + 554 + ] + }, + { + "teal": 581, + "source": 159, + "pc": [ + 555 + ] + }, + { + "teal": 582, + "source": 159, + "pc": [ + 556 + ] + }, + { + "teal": 583, + "source": 159, + "pc": [ + 557, + 558 + ] + }, + { + "teal": 587, + "source": 160, + "pc": [ + 559, + 560 + ] + }, + { + "teal": 588, + "source": 160, + "pc": [ + 561, + 562 + ] + }, + { + "teal": 589, + "source": 160, + "pc": [ + 563, + 564 + ] + }, + { + "teal": 590, + "source": 160, + "pc": [ + 565 + ] + }, + { + "teal": 591, + "source": 160, + "pc": [ + 566 + ] + }, + { + "teal": 592, + "source": 160, + "pc": [ + 567, + 568 + ] + }, + { + "teal": 596, + "source": 161, + "pc": [ + 569, + 570 + ] + }, + { + "teal": 597, + "source": 161, + "pc": [ + 571, + 572 + ] + }, + { + "teal": 600, + "source": 159, + "pc": [ + 573 + ] + }, + { + "teal": 601, + "source": 159, + "pc": [ + 574, + 575 + ] + }, + { + "teal": 604, + "source": 159, + "pc": [ + 576 + ] + }, + { + "teal": 605, + "source": 143, + "pc": [ + 577 + ] + }, + { + "teal": 610, + "source": 168, + "pc": [ + 578, + 579, + 580 + ] + }, + { + "teal": 611, + "source": 168, + "pc": [ + 581 + ] + }, + { + "teal": 612, + "source": 168, + "pc": [ + 582 + ] + }, + { + "teal": 618, + "source": 168, + "pc": [ + 583, + 584, + 585 + ] + }, + { + "teal": 622, + "source": 169, + "pc": [ + 586, + 587 + ] + }, + { + "teal": 623, + "source": 169, + "pc": [ + 588, + 589 + ] + }, + { + "teal": 624, + "source": 169, + "pc": [ + 590 + ] + }, + { + "teal": 625, + "source": 169, + "pc": [ + 591 + ] + }, + { + "teal": 626, + "source": 168, + "pc": [ + 592 + ] + }, + { + "teal": 631, + "source": 178, + "pc": [ + 593, + 594, + 595 + ] + }, + { + "teal": 632, + "source": 178, + "pc": [ + 596 + ] + }, + { + "teal": 633, + "source": 178, + "pc": [ + 597 + ] + }, + { + "teal": 642, + "source": 178, + "pc": [ + 598, + 599, + 600 + ] + }, + { + "teal": 643, + "source": 178, + "pc": [ + 601 + ] + }, + { + "teal": 646, + "source": 38, + "pc": [ + 602 + ] + }, + { + "teal": 647, + "source": 38, + "pc": [ + 603 + ] + }, + { + "teal": 650, + "source": 38, + "pc": [ + 604, + 605, + 606, + 607, + 608, + 609 + ] + }, + { + "teal": 651, + "source": 38, + "pc": [ + 610, + 611, + 612 + ] + }, + { + "teal": 652, + "source": 38, + "pc": [ + 613, + 614, + 615, + 616 + ] + }, + { + "teal": 655, + "source": 38, + "errorMessage": "this contract does not implement the given ABI method for create NoOp", + "pc": [ + 617 + ] + }, + { + "teal": 658, + "source": 38, + "pc": [ + 618, + 619, + 620, + 621, + 622, + 623 + ] + }, + { + "teal": 659, + "source": 38, + "pc": [ + 624, + 625, + 626, + 627, + 628, + 629 + ] + }, + { + "teal": 660, + "source": 38, + "pc": [ + 630, + 631, + 632, + 633, + 634, + 635 + ] + }, + { + "teal": 661, + "source": 38, + "pc": [ + 636, + 637, + 638, + 639, + 640, + 641 + ] + }, + { + "teal": 662, + "source": 38, + "pc": [ + 642, + 643, + 644, + 645, + 646, + 647 + ] + }, + { + "teal": 663, + "source": 38, + "pc": [ + 648, + 649, + 650, + 651, + 652, + 653 + ] + }, + { + "teal": 664, + "source": 38, + "pc": [ + 654, + 655, + 656 + ] + }, + { + "teal": 665, + "source": 38, + "pc": [ + 657, + 658, + 659, + 660, + 661, + 662, + 663, + 664, + 665, + 666, + 667, + 668, + 669, + 670 + ] + }, + { + "teal": 668, + "source": 38, + "errorMessage": "this contract does not implement the given ABI method for call NoOp", + "pc": [ + 671 + ] + }, + { + "teal": 671, + "source": 38, + "pc": [ + 672, + 673, + 674, + 675, + 676, + 677 + ] + }, + { + "teal": 672, + "source": 38, + "pc": [ + 678, + 679, + 680 + ] + }, + { + "teal": 673, + "source": 38, + "pc": [ + 681, + 682, + 683, + 684 + ] + }, + { + "teal": 676, + "source": 38, + "errorMessage": "this contract does not implement the given ABI method for call UpdateApplication", + "pc": [ + 685 + ] + } + ], + "source": { + "approval": "#pragma version 10

// This TEAL was generated by TEALScript v0.96.0
// https://github.com/algorandfoundation/TEALScript

// This contract is compliant with and/or implements the following ARCs: [ ARC4 ]

// The following ten lines of TEAL handle initial program flow
// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed
// Here, action refers to the OnComplete in combination with whether the app is being created or called
// Every possible action for this contract is represented in the switch statement
// If the action is not implemented in the contract, its respective branch will be "*NOT_IMPLEMENTED" which just contains "err"
txn ApplicationID
!
int 6
*
txn OnCompletion
+
switch *call_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *call_UpdateApplication *NOT_IMPLEMENTED *create_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED

*NOT_IMPLEMENTED:
	// The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?
	err

// startUpload(address,uint64,uint64,pay)void
*abi_route_startUpload:
	// mbrPayment: pay
	txn GroupIndex
	int 1
	-
	dup
	gtxns TypeEnum
	int pay
	==

	// argument 0 (mbrPayment) for startUpload must be a pay transaction
	assert

	// endBoxSize: uint64
	txna ApplicationArgs 3
	btoi

	// numBoxes: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 3 (pubKey) for startUpload must be a address
	assert

	// execute startUpload(address,uint64,uint64,pay)void
	callsub startUpload
	int 1
	return

// startUpload(pubKey: Address, numBoxes: uint64, endBoxSize: uint64, mbrPayment: PayTxn): void
//
//
// Allocate boxes to begin data upload process
//
// @param pubKey The pubkey of the DID
// @param numBoxes The number of boxes that the data will take up
// @param endBoxSize The size of the last box
// @param mbrPayment Payment from the uploader to cover the box MBR
startUpload:
	proto 4 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x
	dupn 3

	// contracts/algo-did.algo.ts:63
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:65
	// startBox = this.currentIndex.value
	byte 0x63757272656e74496e646578 // "currentIndex"
	app_global_get
	frame_bury 0 // startBox: uint64

	// contracts/algo-did.algo.ts:66
	// endBox = startBox + numBoxes - 1
	frame_dig 0 // startBox: uint64
	frame_dig -2 // numBoxes: uint64
	+
	int 1
	-
	frame_bury 1 // endBox: uint64

	// contracts/algo-did.algo.ts:68
	// metadata: Metadata = {
	//       start: startBox, end: endBox, status: UPLOADING, endSize: endBoxSize, lastDeleted: 0,
	//     }
	frame_dig 0 // startBox: uint64
	itob
	frame_dig 1 // endBox: uint64
	itob
	concat
	byte 0x00
	concat
	frame_dig -3 // endBoxSize: uint64
	itob
	concat
	byte 0x0000000000000000
	concat
	frame_bury 2 // metadata: Metadata

	// contracts/algo-did.algo.ts:72
	// assert(!this.metadata(pubKey).exists)
	frame_dig -1 // pubKey: Address
	box_len
	swap
	pop
	!
	assert

	// contracts/algo-did.algo.ts:74
	// this.metadata(pubKey).value = metadata
	frame_dig -1 // pubKey: Address
	frame_dig 2 // metadata: Metadata
	box_put

	// contracts/algo-did.algo.ts:76
	// this.currentIndex.value = endBox + 1
	byte 0x63757272656e74496e646578 // "currentIndex"
	frame_dig 1 // endBox: uint64
	int 1
	+
	app_global_put

	// contracts/algo-did.algo.ts:78
	// totalCost = numBoxes * COST_PER_BOX // cost of data boxes
	//     + (numBoxes - 1) * MAX_BOX_SIZE * COST_PER_BYTE // cost of data
	//     + numBoxes * 8 * COST_PER_BYTE // cost of data keys
	//     + endBoxSize * COST_PER_BYTE // cost of last data box
	//     + COST_PER_BOX + (8 + 8 + 1 + 8 + 32 + 8) * COST_PER_BYTE
	frame_dig -2 // numBoxes: uint64
	int 2500
	*
	frame_dig -2 // numBoxes: uint64
	int 1
	-
	int 32768
	*
	int 400
	*
	+
	frame_dig -2 // numBoxes: uint64
	int 8
	*
	int 400
	*
	+
	frame_dig -3 // endBoxSize: uint64
	int 400
	*
	+
	int 2500
	+
	int 26000
	+
	frame_bury 3 // totalCost: uint64

	// contracts/algo-did.algo.ts:84
	// assert(mbrPayment.amount === totalCost)
	frame_dig -4 // mbrPayment: PayTxn
	gtxns Amount
	frame_dig 3 // totalCost: uint64
	==
	assert

	// contracts/algo-did.algo.ts:85
	// assert(mbrPayment.receiver === this.app.address)
	frame_dig -4 // mbrPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==
	assert
	retsub

// upload(address,uint64,uint64,byte[])void
*abi_route_upload:
	// data: byte[]
	txna ApplicationArgs 4
	extract 2 0

	// offset: uint64
	txna ApplicationArgs 3
	btoi

	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 3 (pubKey) for upload must be a address
	assert

	// execute upload(address,uint64,uint64,byte[])void
	callsub upload
	int 1
	return

// upload(pubKey: Address, boxIndex: uint64, offset: uint64, data: bytes): void
//
//
// Upload data to a specific offset in a box
//
// @param pubKey The pubkey of the DID
// @param boxIndex The index of the box to upload the given chunk of data to
// @param offset The offset within the box to start writing the data
// @param data The data to write
upload:
	proto 4 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x

	// contracts/algo-did.algo.ts:98
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:100
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: Address
	frame_bury 0 // storage key//metadata

	// contracts/algo-did.algo.ts:101
	// assert(metadata.status === UPLOADING)
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	int 1
	box_extract
	btoi
	int 0
	==
	assert

	// contracts/algo-did.algo.ts:102
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -1 // pubKey: Address
	int 0
	int 8
	box_extract
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz *skip_and0
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	<=
	&&

*skip_and0:
	assert

	// *if0_condition
	// contracts/algo-did.algo.ts:104
	// offset === 0
	frame_dig -3 // offset: uint64
	int 0
	==
	bz *if0_end

	// *if0_consequent
	// contracts/algo-did.algo.ts:105
	// this.dataBoxes(boxIndex).create(boxIndex === metadata.end ? metadata.endSize : MAX_BOX_SIZE)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	==
	bz *ternary0_false
	frame_dig -1 // pubKey: Address
	int 17 // headOffset
	int 8
	box_extract
	btoi
	b *ternary0_end

*ternary0_false:
	int 32768

*ternary0_end:
	box_create
	pop

*if0_end:
	// contracts/algo-did.algo.ts:108
	// this.dataBoxes(boxIndex).replace(offset, data)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -3 // offset: uint64
	frame_dig -4 // data: bytes
	box_replace
	retsub

// finishUpload(address)void
*abi_route_finishUpload:
	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 0 (pubKey) for finishUpload must be a address
	assert

	// execute finishUpload(address)void
	callsub finishUpload
	int 1
	return

// finishUpload(pubKey: Address): void
//
//
// Mark uploading as false
//
// @param pubKey The address of the DID
finishUpload:
	proto 1 0

	// contracts/algo-did.algo.ts:118
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:120
	// this.metadata(pubKey).value.status = READY
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	byte 0x01
	box_replace
	retsub

// startDelete(address)void
*abi_route_startDelete:
	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 0 (pubKey) for startDelete must be a address
	assert

	// execute startDelete(address)void
	callsub startDelete
	int 1
	return

// startDelete(pubKey: Address): void
//
// Starts the deletion process for the data associated with a DID
//
// @param pubKey The address of the DID
startDelete:
	proto 1 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x

	// contracts/algo-did.algo.ts:129
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:131
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: Address
	frame_bury 0 // storage key//metadata

	// contracts/algo-did.algo.ts:132
	// assert(metadata.status === READY)
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	int 1
	box_extract
	btoi
	int 1
	==
	assert

	// contracts/algo-did.algo.ts:134
	// metadata.status = DELETING
	frame_dig 0 // storage key//metadata
	int 16 // headOffset
	byte 0x02
	box_replace
	retsub

// deleteData(address,uint64)void
*abi_route_deleteData:
	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 1 (pubKey) for deleteData must be a address
	assert

	// execute deleteData(address,uint64)void
	callsub deleteData
	int 1
	return

// deleteData(pubKey: Address, boxIndex: uint64): void
//
// Deletes a box of data
//
// @param pubKey The address of the DID
// @param boxIndex The index of the box to delete
deleteData:
	proto 2 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x
	dup

	// contracts/algo-did.algo.ts:144
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:146
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: Address
	frame_bury 0 // storage key//metadata

	// contracts/algo-did.algo.ts:147
	// assert(metadata.status === DELETING)
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	int 1
	box_extract
	btoi
	int 2
	==
	assert

	// contracts/algo-did.algo.ts:148
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -1 // pubKey: Address
	int 0
	int 8
	box_extract
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz *skip_and1
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	<=
	&&

*skip_and1:
	assert

	// *if1_condition
	// contracts/algo-did.algo.ts:150
	// boxIndex !== metadata.start
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 0
	int 8
	box_extract
	btoi
	!=
	bz *if1_end

	// *if1_consequent
	// contracts/algo-did.algo.ts:150
	// assert(metadata.lastDeleted === boxIndex - 1)
	frame_dig -1 // pubKey: Address
	int 25 // headOffset
	int 8
	box_extract
	btoi
	frame_dig -2 // boxIndex: uint64
	int 1
	-
	==
	assert

*if1_end:
	// contracts/algo-did.algo.ts:152
	// preMBR = globals.currentApplicationAddress.minBalance
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	pop
	frame_bury 1 // preMBR: uint64

	// contracts/algo-did.algo.ts:154
	// this.dataBoxes(boxIndex).delete()
	frame_dig -2 // boxIndex: uint64
	itob
	box_del

	// *if2_condition
	// contracts/algo-did.algo.ts:156
	// boxIndex === metadata.end
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	==
	bz *if2_else

	// *if2_consequent
	// contracts/algo-did.algo.ts:156
	// this.metadata(pubKey).delete()
	frame_dig -1 // pubKey: Address
	box_del
	b *if2_end

*if2_else:
	// contracts/algo-did.algo.ts:157
	// metadata.lastDeleted = boxIndex
	int 25 // headOffset
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig 0 // storage key//metadata
	cover 2
	box_replace

*if2_end:
	// contracts/algo-did.algo.ts:159
	// sendPayment({
	//       amount: preMBR - globals.currentApplicationAddress.minBalance,
	//       receiver: this.txn.sender,
	//     })
	itxn_begin
	int pay
	itxn_field TypeEnum

	// contracts/algo-did.algo.ts:160
	// amount: preMBR - globals.currentApplicationAddress.minBalance
	frame_dig 1 // preMBR: uint64
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	pop
	-
	itxn_field Amount

	// contracts/algo-did.algo.ts:161
	// receiver: this.txn.sender
	txn Sender
	itxn_field Receiver

	// Fee field not set, defaulting to 0
	int 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// updateApplication()void
*abi_route_updateApplication:
	// execute updateApplication()void
	callsub updateApplication
	int 1
	return

// updateApplication(): void
//
// Allow the contract to be updated by the creator
updateApplication:
	proto 0 0

	// contracts/algo-did.algo.ts:169
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert
	retsub

// dummy()void
*abi_route_dummy:
	// execute dummy()void
	callsub dummy
	int 1
	return

// dummy(): void
//
// Dummy function to add extra box references for deleteData.
// Boxes are 32k, but a single app call can only inlcude enough references to read/write 8k
// at a time. Thus when a box is deleted, we need to add additional dummy calls with box
// references to increase the total read/write budget to 32k.
dummy:
	proto 0 0
	retsub

*abi_route_createApplication:
	int 1
	return

*create_NoOp:
	method "createApplication()void"
	txna ApplicationArgs 0
	match *abi_route_createApplication

	// this contract does not implement the given ABI method for create NoOp
	err

*call_NoOp:
	method "startUpload(address,uint64,uint64,pay)void"
	method "upload(address,uint64,uint64,byte[])void"
	method "finishUpload(address)void"
	method "startDelete(address)void"
	method "deleteData(address,uint64)void"
	method "dummy()void"
	txna ApplicationArgs 0
	match *abi_route_startUpload *abi_route_upload *abi_route_finishUpload *abi_route_startDelete *abi_route_deleteData *abi_route_dummy

	// this contract does not implement the given ABI method for call NoOp
	err

*call_UpdateApplication:
	method "updateApplication()void"
	txna ApplicationArgs 0
	match *abi_route_updateApplication

	// this contract does not implement the given ABI method for call UpdateApplication
	err", + "clear": "I3ByYWdtYSB2ZXJzaW9uIDEw" + }, + "byteCode": { + "approval": "CiAJAQgAIBCQA8QTgIACGSYCAAxjdXJyZW50SW5kZXgxGBSBBgsxGQiNDAInAAAAAAAAAl0AAAIZAAAAAAAAAAAAAAAxFiIJSTgQIhJENhoDFzYaAhc2GgFJFSUSRIgAAiJDigQAKEcDMQAyCRJEKWSMAIsAi/4IIgmMAYsAFosBFlCAAQBQi/0WUIAIAAAAAAAAAABQjAKL/71MSBREi/+LAr8piwEiCGeL/iEGC4v+IgkhBwshBQsIi/4jCyEFCwiL/SEFCwghBgiBkMsBCIwDi/w4CIsDEkSL/DgHMgoSRIk2GgRXAgA2GgMXNhoCFzYaAUkVJRJEiAACIkOKBAAoMQAyCRJEi/+MAIv/IQQiuhckEkSL/yQjuheL/g5JQQAKi/6L/yMjuhcOEESL/SQSQQAdi/4Wi/6L/yMjuhcSQQAKi/+BESO6F0IAAiEHuUiL/haL/Yv8u4k2GgFJFSUSRIgAAiJDigEAMQAyCRJEi/8hBIABAbuJNhoBSRUlEkSIAAIiQ4oBACgxADIJEkSL/4wAi/8hBCK6FyISRIsAIQSAAQK7iTYaAhc2GgFJFSUSRIgAAiJDigIAKEkxADIJEkSL/4wAi/8hBCK6F4ECEkSL/yQjuheL/g5JQQAKi/6L/yMjuhcOEESL/ov/JCO6FxNBAA2L/yEII7oXi/4iCRJEMgpzAUiMAYv+FryL/ov/IyO6FxJBAAaL/7xCAAohCIv+FosATgK7sSKyEIsBMgpzAUgJsggxALIHJLIBs4mIAAIiQ4oAADEAMgkSRImIAAIiQ4oAAIkiQ4AEuER7NjYaAI4B//EAgARWXGddgARNscQYgAQOeHJXgAS9LITigARokbqQgASjDOf/NhoAjgb9pf5E/rz+2/8J/7IAgARG92UzNhoAjgH/lQA=", + "clear": "Cg==" + }, + "compilerInfo": { + "compiler": "algod", + "compilerVersion": { + "major": 3, + "minor": 24, + "patch": 0, + "commitHash": "5c2cf06d" + } + } +} \ No newline at end of file diff --git a/reference_contract/contracts/artifacts/AlgoDID.clear.teal b/reference_contract/contracts/artifacts/AlgoDID.clear.teal new file mode 100644 index 0000000..e9f1d65 --- /dev/null +++ b/reference_contract/contracts/artifacts/AlgoDID.clear.teal @@ -0,0 +1 @@ +#pragma version 10 \ No newline at end of file diff --git a/reference_contract/contracts/artifacts/AlgoDID.json b/reference_contract/contracts/artifacts/AlgoDID.json new file mode 100644 index 0000000..a3317c5 --- /dev/null +++ b/reference_contract/contracts/artifacts/AlgoDID.json @@ -0,0 +1,223 @@ +{ + "hints": { + "startUpload(address,uint64,uint64,pay)void": { + "call_config": { + "no_op": "CALL" + } + }, + "upload(address,uint64,uint64,byte[])void": { + "call_config": { + "no_op": "CALL" + } + }, + "finishUpload(address)void": { + "call_config": { + "no_op": "CALL" + } + }, + "startDelete(address)void": { + "call_config": { + "no_op": "CALL" + } + }, + "deleteData(address,uint64)void": { + "call_config": { + "no_op": "CALL" + } + }, + "updateApplication()void": { + "call_config": { + "update_application": "CALL" + } + }, + "dummy()void": { + "call_config": { + "no_op": "CALL" + } + }, + "createApplication()void": { + "call_config": { + "no_op": "CREATE" + } + } + }, + "bare_call_config": { + "no_op": "NEVER", + "opt_in": "NEVER", + "close_out": "NEVER", + "update_application": "NEVER", + "delete_application": "NEVER" + }, + "schema": { + "local": { + "declared": {}, + "reserved": {} + }, + "global": { + "declared": { + "currentIndex": { + "type": "uint64", + "key": "currentIndex" + } + }, + "reserved": {} + } + }, + "state": { + "global": { + "num_byte_slices": 0, + "num_uints": 1 + }, + "local": { + "num_byte_slices": 0, + "num_uints": 0 + } + }, + "source": { + "approval": "#pragma version 9

// This TEAL was generated by TEALScript v0.51.1
// https://github.com/algorand-devrel/TEALScript

// This contract is compliant with and/or implements the following ARCs: [ ARC4 ]

// The following ten lines of TEAL handle initial program flow
// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed
// Here, action refers to the OnComplete in combination with whether the app is being created or called
// Every possible action for this contract is represented in the switch statement
// If the action is not implmented in the contract, its repsective branch will be "NOT_IMPLMENTED" which just contains "err"
txn ApplicationID
int 0
>
int 6
*
txn OnCompletion
+
switch create_NoOp NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED call_NoOp NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED call_UpdateApplication

NOT_IMPLEMENTED:
	err

// startUpload(pay,uint64,uint64,address)void
//
// 
// Allocate boxes to begin data upload process
// 
// @param pubKey The pubkey of the DID
// @param numBoxes The number of boxes that the data will take up
// @param endBoxSize The size of the last box
// @param mbrPayment Payment from the uploader to cover the box MBR
abi_route_startUpload:
	byte 0x; dupn 3 // push empty bytes to fill the stack frame for this subroutine's local variables

	// mbrPayment: pay
	txn GroupIndex
	int 1
	-
	dup
	gtxns TypeEnum
	int pay
	==
	assert

	// endBoxSize: uint64
	txna ApplicationArgs 3
	btoi

	// numBoxes: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute startUpload(pay,uint64,uint64,address)void
	callsub startUpload
	int 1
	return

startUpload:
	proto 8 0

	// contracts/algo-did.algo.ts:64
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:66
	// startBox = this.currentIndex.value
	byte 0x63757272656e74496e646578 // "currentIndex"
	app_global_get
	frame_bury -5 // startBox: uint64

	// contracts/algo-did.algo.ts:67
	// endBox = startBox + numBoxes - 1
	frame_dig -5 // startBox: uint64
	frame_dig -2 // numBoxes: uint64
	+
	int 1
	-
	frame_bury -6 // endBox: uint64

	// contracts/algo-did.algo.ts:69
	// metadata: Metadata = {
	//       start: startBox, end: endBox, status: UPLOADING, endSize: endBoxSize, lastDeleted: 0,
	//     }
	frame_dig -5 // startBox: uint64
	itob
	frame_dig -6 // endBox: uint64
	itob
	concat
	byte 0x00
	byte 0x00
	bitlen
	int 8
	<=
	assert
	byte 0xFF
	b&
	concat
	frame_dig -3 // endBoxSize: uint64
	itob
	concat
	byte 0x0000000000000000
	concat
	frame_bury -7 // metadata: Metadata

	// contracts/algo-did.algo.ts:73
	// assert(!this.metadata(pubKey).exists)
	frame_dig -1 // pubKey: address
	box_len
	swap
	pop
	!
	assert

	// contracts/algo-did.algo.ts:75
	// this.metadata(pubKey).value = metadata
	frame_dig -1 // pubKey: address
	frame_dig -7 // metadata: Metadata
	box_put

	// contracts/algo-did.algo.ts:77
	// this.currentIndex.value = endBox + 1
	byte 0x63757272656e74496e646578 // "currentIndex"
	frame_dig -6 // endBox: uint64
	int 1
	+
	app_global_put

	// contracts/algo-did.algo.ts:79
	// totalCost = numBoxes * COST_PER_BOX // cost of data boxes
	//     + (numBoxes - 1) * MAX_BOX_SIZE * COST_PER_BYTE // cost of data
	//     + numBoxes * 8 * COST_PER_BYTE // cost of data keys
	//     + endBoxSize * COST_PER_BYTE // cost of last data box
	//     + COST_PER_BOX + (8 + 8 + 1 + 8 + 32 + 8) * COST_PER_BYTE
	frame_dig -2 // numBoxes: uint64
	int 2500
	*
	frame_dig -2 // numBoxes: uint64
	int 1
	-
	int 32768
	*
	int 400
	*
	+
	frame_dig -2 // numBoxes: uint64
	int 8
	*
	int 400
	*
	+
	frame_dig -3 // endBoxSize: uint64
	int 400
	*
	+
	int 2500
	+
	int 26000
	+
	frame_bury -8 // totalCost: uint64

	// contracts/algo-did.algo.ts:85
	// assert(mbrPayment.amount === totalCost)
	frame_dig -4 // mbrPayment: pay
	gtxns Amount
	frame_dig -8 // totalCost: uint64
	==
	assert

	// contracts/algo-did.algo.ts:86
	// assert(mbrPayment.receiver === this.app.address)
	frame_dig -4 // mbrPayment: pay
	gtxns Receiver
	global CurrentApplicationAddress
	==
	assert
	retsub

// upload(bytes,uint64,uint64,address)void
//
// 
// Upload data to a specific offset in a box
// 
// @param pubKey The pubkey of the DID
// @param boxIndex The index of the box to upload the given chunk of data to
// @param offset The offset within the box to start writing the data
// @param data The data to write
abi_route_upload:
	byte 0x // push empty bytes to fill the stack frame for this subroutine's local variables

	// data: byte[]
	txna ApplicationArgs 4
	extract 2 0

	// offset: uint64
	txna ApplicationArgs 3
	btoi

	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute upload(bytes,uint64,uint64,address)void
	callsub upload
	int 1
	return

upload:
	proto 5 0

	// contracts/algo-did.algo.ts:99
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:101
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: address
	frame_bury -5 // storage key//metadata

	// contracts/algo-did.algo.ts:102
	// assert(metadata.status === UPLOADING)
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 16 1
	byte 0x0000000000000000
	b==
	assert

	// contracts/algo-did.algo.ts:103
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 0 8
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz skip_and0
	frame_dig -2 // boxIndex: uint64
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 8 8
	btoi
	<=
	&&

skip_and0:
	assert

	// if0_condition
	// contracts/algo-did.algo.ts:105
	// offset === 0
	frame_dig -3 // offset: uint64
	int 0
	==
	bz if0_end

	// if0_consequent
	// contracts/algo-did.algo.ts:106
	// this.dataBoxes(boxIndex).create(boxIndex === metadata.end ? metadata.endSize : MAX_BOX_SIZE)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -2 // boxIndex: uint64
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 8 8
	btoi
	==
	bz ternary0_false
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 17 8
	btoi
	b ternary0_end

ternary0_false:
	int 32768

ternary0_end:
	box_create

if0_end:
	// contracts/algo-did.algo.ts:109
	// this.dataBoxes(boxIndex).replace(offset, data)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -3 // offset: uint64
	frame_dig -4 // data: bytes
	box_replace
	retsub

// finishUpload(address)void
//
// 
// Mark uploading as false
// 
// @param pubKey The address of the DID
abi_route_finishUpload:
	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute finishUpload(address)void
	callsub finishUpload
	int 1
	return

finishUpload:
	proto 1 0

	// contracts/algo-did.algo.ts:119
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:121
	// this.metadata(pubKey).value.status = READY
	frame_dig -1 // pubKey: address
	int 16
	byte 0x01
	box_replace
	retsub

// startDelete(address)void
//
// Starts the deletion process for the data associated with a DID
// 
// @param pubKey The address of the DID
abi_route_startDelete:
	byte 0x // push empty bytes to fill the stack frame for this subroutine's local variables

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute startDelete(address)void
	callsub startDelete
	int 1
	return

startDelete:
	proto 2 0

	// contracts/algo-did.algo.ts:130
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:132
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: address
	frame_bury -2 // storage key//metadata

	// contracts/algo-did.algo.ts:133
	// assert(metadata.status === READY)
	frame_dig -2 // storage key//metadata
	box_get
	assert
	extract 16 1
	byte 0x0000000000000001
	b==
	assert

	// contracts/algo-did.algo.ts:135
	// metadata.status = DELETING
	frame_dig -2 // storage key//metadata
	box_get
	assert
	byte 0x02
	replace2 16
	frame_dig -2 // storage key//metadata
	swap
	box_put
	retsub

// deleteData(uint64,address)void
//
// Deletes a box of data
// 
// @param pubKey The address of the DID
// @param boxIndex The index of the box to delete
abi_route_deleteData:
	byte 0x; dup // push empty bytes to fill the stack frame for this subroutine's local variables

	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute deleteData(uint64,address)void
	callsub deleteData
	int 1
	return

deleteData:
	proto 4 0

	// contracts/algo-did.algo.ts:145
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:147
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: address
	frame_bury -3 // storage key//metadata

	// contracts/algo-did.algo.ts:148
	// assert(metadata.status === DELETING)
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 16 1
	byte 0x0000000000000002
	b==
	assert

	// contracts/algo-did.algo.ts:149
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 0 8
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz skip_and1
	frame_dig -2 // boxIndex: uint64
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 8 8
	btoi
	<=
	&&

skip_and1:
	assert

	// if1_condition
	// contracts/algo-did.algo.ts:151
	// boxIndex !== metadata.start
	frame_dig -2 // boxIndex: uint64
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 0 8
	btoi
	!=
	bz if1_end

	// if1_consequent
	// contracts/algo-did.algo.ts:151
	// assert(metadata.lastDeleted === boxIndex - 1)
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 25 8
	btoi
	frame_dig -2 // boxIndex: uint64
	int 1
	-
	==
	assert

if1_end:
	// contracts/algo-did.algo.ts:153
	// preMBR = globals.currentApplicationAddress.minBalance
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	assert
	frame_bury -4 // preMBR: uint64

	// contracts/algo-did.algo.ts:155
	// this.dataBoxes(boxIndex).delete()
	frame_dig -2 // boxIndex: uint64
	itob
	box_del

	// if2_condition
	// contracts/algo-did.algo.ts:157
	// boxIndex === metadata.end
	frame_dig -2 // boxIndex: uint64
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 8 8
	btoi
	==
	bz if2_else

	// if2_consequent
	// contracts/algo-did.algo.ts:157
	// this.metadata(pubKey).delete()
	frame_dig -1 // pubKey: address
	box_del
	b if2_end

if2_else:
	// contracts/algo-did.algo.ts:158
	// metadata.lastDeleted = boxIndex
	frame_dig -3 // storage key//metadata
	box_get
	assert
	frame_dig -2 // boxIndex: uint64
	itob
	replace2 25
	frame_dig -3 // storage key//metadata
	swap
	box_put

if2_end:
	// contracts/algo-did.algo.ts:160
	// sendPayment({
	//       amount: preMBR - globals.currentApplicationAddress.minBalance,
	//       receiver: this.txn.sender,
	//     })
	itxn_begin
	int pay
	itxn_field TypeEnum

	// contracts/algo-did.algo.ts:161
	// amount: preMBR - globals.currentApplicationAddress.minBalance
	frame_dig -4 // preMBR: uint64
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	assert
	-
	itxn_field Amount

	// contracts/algo-did.algo.ts:162
	// receiver: this.txn.sender
	txn Sender
	itxn_field Receiver

	// Fee field not set, defaulting to 0
	int 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// updateApplication()void
//
// Allow the contract to be updated by the creator
abi_route_updateApplication:
	// execute updateApplication()void
	callsub updateApplication
	int 1
	return

updateApplication:
	proto 0 0

	// contracts/algo-did.algo.ts:170
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert
	retsub

// dummy()void
//
// Dummy function to add extra box references for deleteData.
// Boxes are 32k, but a single app call can only inlcude enough references to read/write 8k
// at a time. Thus when a box is deleted, we need to add additional dummy calls with box
// references to increase the total read/write budget to 32k.
abi_route_dummy:
	// execute dummy()void
	callsub dummy
	int 1
	return

dummy:
	proto 0 0
	retsub

abi_route_createApplication:
	int 1
	return

create_NoOp:
	method "createApplication()void"
	txna ApplicationArgs 0
	match abi_route_createApplication
	err

call_NoOp:
	method "startUpload(address,uint64,uint64,pay)void"
	method "upload(address,uint64,uint64,byte[])void"
	method "finishUpload(address)void"
	method "startDelete(address)void"
	method "deleteData(address,uint64)void"
	method "dummy()void"
	txna ApplicationArgs 0
	match abi_route_startUpload abi_route_upload abi_route_finishUpload abi_route_startDelete abi_route_deleteData abi_route_dummy
	err

call_UpdateApplication:
	method "updateApplication()void"
	txna ApplicationArgs 0
	match abi_route_updateApplication
	err", + "clear": "I3ByYWdtYSB2ZXJzaW9uIDkKaW50IDE=" + }, + "contract": { + "name": "AlgoDID", + "desc": "", + "methods": [ + { + "name": "startUpload", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The pubkey of the DID" + }, + { + "name": "numBoxes", + "type": "uint64", + "desc": "The number of boxes that the data will take up" + }, + { + "name": "endBoxSize", + "type": "uint64", + "desc": "The size of the last box" + }, + { + "name": "mbrPayment", + "type": "pay", + "desc": "Payment from the uploader to cover the box MBR" + } + ], + "desc": "Allocate boxes to begin data upload process", + "returns": { + "type": "void", + "desc": "" + } + }, + { + "name": "upload", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The pubkey of the DID" + }, + { + "name": "boxIndex", + "type": "uint64", + "desc": "The index of the box to upload the given chunk of data to" + }, + { + "name": "offset", + "type": "uint64", + "desc": "The offset within the box to start writing the data" + }, + { + "name": "data", + "type": "byte[]", + "desc": "The data to write" + } + ], + "desc": "Upload data to a specific offset in a box", + "returns": { + "type": "void", + "desc": "" + } + }, + { + "name": "finishUpload", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + } + ], + "desc": "Mark uploading as false", + "returns": { + "type": "void", + "desc": "" + } + }, + { + "name": "startDelete", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + } + ], + "desc": "Starts the deletion process for the data associated with a DID", + "returns": { + "type": "void", + "desc": "" + } + }, + { + "name": "deleteData", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + }, + { + "name": "boxIndex", + "type": "uint64", + "desc": "The index of the box to delete" + } + ], + "desc": "Deletes a box of data", + "returns": { + "type": "void", + "desc": "" + } + }, + { + "name": "updateApplication", + "args": [], + "desc": "Allow the contract to be updated by the creator", + "returns": { + "type": "void", + "desc": "" + } + }, + { + "name": "dummy", + "args": [], + "desc": "Dummy function to add extra box references for deleteData.Boxes are 32k, but a single app call can only inlcude enough references to read/write 8kat a time. Thus when a box is deleted, we need to add additional dummy calls with boxreferences to increase the total read/write budget to 32k.", + "returns": { + "type": "void", + "desc": "" + } + }, + { + "name": "createApplication", + "desc": "", + "returns": { + "type": "void", + "desc": "" + }, + "args": [] + } + ] + } +} \ No newline at end of file diff --git a/reference_contract/contracts/artifacts/AlgoDID.src_map.json b/reference_contract/contracts/artifacts/AlgoDID.src_map.json new file mode 100644 index 0000000..8128601 --- /dev/null +++ b/reference_contract/contracts/artifacts/AlgoDID.src_map.json @@ -0,0 +1,2936 @@ +[ + { + "teal": 1, + "source": 38, + "pc": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31 + ] + }, + { + "teal": 13, + "source": 38, + "pc": [ + 32, + 33 + ] + }, + { + "teal": 14, + "source": 38, + "pc": [ + 34 + ] + }, + { + "teal": 15, + "source": 38, + "pc": [ + 35, + 36 + ] + }, + { + "teal": 16, + "source": 38, + "pc": [ + 37 + ] + }, + { + "teal": 17, + "source": 38, + "pc": [ + 38, + 39 + ] + }, + { + "teal": 18, + "source": 38, + "pc": [ + 40 + ] + }, + { + "teal": 19, + "source": 38, + "pc": [ + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66 + ] + }, + { + "teal": 23, + "source": 38, + "errorMessage": "The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?", + "pc": [ + 67 + ] + }, + { + "teal": 28, + "source": 61, + "pc": [ + 68, + 69 + ] + }, + { + "teal": 29, + "source": 61, + "pc": [ + 70 + ] + }, + { + "teal": 30, + "source": 61, + "pc": [ + 71 + ] + }, + { + "teal": 31, + "source": 61, + "pc": [ + 72 + ] + }, + { + "teal": 32, + "source": 61, + "pc": [ + 73, + 74 + ] + }, + { + "teal": 33, + "source": 61, + "pc": [ + 75 + ] + }, + { + "teal": 34, + "source": 61, + "pc": [ + 76 + ] + }, + { + "teal": 37, + "source": 61, + "errorMessage": "argument 0 (mbrPayment) for startUpload must be a pay transaction", + "pc": [ + 77 + ] + }, + { + "teal": 40, + "source": 60, + "pc": [ + 78, + 79, + 80 + ] + }, + { + "teal": 41, + "source": 60, + "pc": [ + 81 + ] + }, + { + "teal": 44, + "source": 59, + "pc": [ + 82, + 83, + 84 + ] + }, + { + "teal": 45, + "source": 59, + "pc": [ + 85 + ] + }, + { + "teal": 48, + "source": 58, + "pc": [ + 86, + 87, + 88 + ] + }, + { + "teal": 49, + "source": 58, + "pc": [ + 89 + ] + }, + { + "teal": 50, + "source": 58, + "pc": [ + 90 + ] + }, + { + "teal": 51, + "source": 58, + "pc": [ + 91 + ] + }, + { + "teal": 52, + "source": 58, + "pc": [ + 92 + ] + }, + { + "teal": 55, + "source": 58, + "errorMessage": "argument 3 (pubKey) for startUpload must be a address", + "pc": [ + 93 + ] + }, + { + "teal": 58, + "source": 57, + "pc": [ + 94, + 95, + 96 + ] + }, + { + "teal": 59, + "source": 57, + "pc": [ + 97 + ] + }, + { + "teal": 60, + "source": 57, + "pc": [ + 98 + ] + }, + { + "teal": 72, + "source": 57, + "pc": [ + 99, + 100, + 101 + ] + }, + { + "teal": 75, + "source": 57, + "pc": [ + 102 + ] + }, + { + "teal": 76, + "source": 57, + "pc": [ + 103, + 104 + ] + }, + { + "teal": 80, + "source": 63, + "pc": [ + 105, + 106 + ] + }, + { + "teal": 81, + "source": 63, + "pc": [ + 107, + 108 + ] + }, + { + "teal": 82, + "source": 63, + "pc": [ + 109 + ] + }, + { + "teal": 83, + "source": 63, + "pc": [ + 110 + ] + }, + { + "teal": 87, + "source": 65, + "pc": [ + 111 + ] + }, + { + "teal": 88, + "source": 65, + "pc": [ + 112 + ] + }, + { + "teal": 89, + "source": 65, + "pc": [ + 113, + 114 + ] + }, + { + "teal": 93, + "source": 66, + "pc": [ + 115, + 116 + ] + }, + { + "teal": 94, + "source": 66, + "pc": [ + 117, + 118 + ] + }, + { + "teal": 95, + "source": 66, + "pc": [ + 119 + ] + }, + { + "teal": 96, + "source": 66, + "pc": [ + 120 + ] + }, + { + "teal": 97, + "source": 66, + "pc": [ + 121 + ] + }, + { + "teal": 98, + "source": 66, + "pc": [ + 122, + 123 + ] + }, + { + "teal": 104, + "source": 69, + "pc": [ + 124, + 125 + ] + }, + { + "teal": 105, + "source": 69, + "pc": [ + 126 + ] + }, + { + "teal": 106, + "source": 69, + "pc": [ + 127, + 128 + ] + }, + { + "teal": 107, + "source": 69, + "pc": [ + 129 + ] + }, + { + "teal": 108, + "source": 69, + "pc": [ + 130 + ] + }, + { + "teal": 109, + "source": 69, + "pc": [ + 131, + 132, + 133 + ] + }, + { + "teal": 110, + "source": 69, + "pc": [ + 134 + ] + }, + { + "teal": 111, + "source": 69, + "pc": [ + 135, + 136 + ] + }, + { + "teal": 112, + "source": 69, + "pc": [ + 137 + ] + }, + { + "teal": 113, + "source": 69, + "pc": [ + 138 + ] + }, + { + "teal": 114, + "source": 69, + "pc": [ + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148 + ] + }, + { + "teal": 115, + "source": 69, + "pc": [ + 149 + ] + }, + { + "teal": 116, + "source": 68, + "pc": [ + 150, + 151 + ] + }, + { + "teal": 120, + "source": 72, + "pc": [ + 152, + 153 + ] + }, + { + "teal": 121, + "source": 72, + "pc": [ + 154 + ] + }, + { + "teal": 122, + "source": 72, + "pc": [ + 155 + ] + }, + { + "teal": 123, + "source": 72, + "pc": [ + 156 + ] + }, + { + "teal": 124, + "source": 72, + "pc": [ + 157 + ] + }, + { + "teal": 125, + "source": 72, + "pc": [ + 158 + ] + }, + { + "teal": 129, + "source": 74, + "pc": [ + 159, + 160 + ] + }, + { + "teal": 130, + "source": 74, + "pc": [ + 161, + 162 + ] + }, + { + "teal": 131, + "source": 74, + "pc": [ + 163 + ] + }, + { + "teal": 135, + "source": 76, + "pc": [ + 164 + ] + }, + { + "teal": 136, + "source": 76, + "pc": [ + 165, + 166 + ] + }, + { + "teal": 137, + "source": 76, + "pc": [ + 167 + ] + }, + { + "teal": 138, + "source": 76, + "pc": [ + 168 + ] + }, + { + "teal": 139, + "source": 76, + "pc": [ + 169 + ] + }, + { + "teal": 147, + "source": 78, + "pc": [ + 170, + 171 + ] + }, + { + "teal": 148, + "source": 78, + "pc": [ + 172, + 173 + ] + }, + { + "teal": 149, + "source": 78, + "pc": [ + 174 + ] + }, + { + "teal": 150, + "source": 79, + "pc": [ + 175, + 176 + ] + }, + { + "teal": 151, + "source": 79, + "pc": [ + 177 + ] + }, + { + "teal": 152, + "source": 79, + "pc": [ + 178 + ] + }, + { + "teal": 153, + "source": 79, + "pc": [ + 179, + 180 + ] + }, + { + "teal": 154, + "source": 79, + "pc": [ + 181 + ] + }, + { + "teal": 155, + "source": 79, + "pc": [ + 182, + 183 + ] + }, + { + "teal": 156, + "source": 79, + "pc": [ + 184 + ] + }, + { + "teal": 157, + "source": 79, + "pc": [ + 185 + ] + }, + { + "teal": 158, + "source": 80, + "pc": [ + 186, + 187 + ] + }, + { + "teal": 159, + "source": 80, + "pc": [ + 188 + ] + }, + { + "teal": 160, + "source": 80, + "pc": [ + 189 + ] + }, + { + "teal": 161, + "source": 80, + "pc": [ + 190, + 191 + ] + }, + { + "teal": 162, + "source": 80, + "pc": [ + 192 + ] + }, + { + "teal": 163, + "source": 80, + "pc": [ + 193 + ] + }, + { + "teal": 164, + "source": 81, + "pc": [ + 194, + 195 + ] + }, + { + "teal": 165, + "source": 81, + "pc": [ + 196, + 197 + ] + }, + { + "teal": 166, + "source": 81, + "pc": [ + 198 + ] + }, + { + "teal": 167, + "source": 81, + "pc": [ + 199 + ] + }, + { + "teal": 168, + "source": 82, + "pc": [ + 200, + 201 + ] + }, + { + "teal": 169, + "source": 82, + "pc": [ + 202 + ] + }, + { + "teal": 170, + "source": 82, + "pc": [ + 203, + 204, + 205, + 206 + ] + }, + { + "teal": 171, + "source": 82, + "pc": [ + 207 + ] + }, + { + "teal": 172, + "source": 78, + "pc": [ + 208, + 209 + ] + }, + { + "teal": 176, + "source": 84, + "pc": [ + 210, + 211 + ] + }, + { + "teal": 177, + "source": 84, + "pc": [ + 212, + 213 + ] + }, + { + "teal": 178, + "source": 84, + "pc": [ + 214, + 215 + ] + }, + { + "teal": 179, + "source": 84, + "pc": [ + 216 + ] + }, + { + "teal": 180, + "source": 84, + "pc": [ + 217 + ] + }, + { + "teal": 184, + "source": 85, + "pc": [ + 218, + 219 + ] + }, + { + "teal": 185, + "source": 85, + "pc": [ + 220, + 221 + ] + }, + { + "teal": 186, + "source": 85, + "pc": [ + 222, + 223 + ] + }, + { + "teal": 187, + "source": 85, + "pc": [ + 224 + ] + }, + { + "teal": 188, + "source": 85, + "pc": [ + 225 + ] + }, + { + "teal": 189, + "source": 57, + "pc": [ + 226 + ] + }, + { + "teal": 194, + "source": 97, + "pc": [ + 227, + 228, + 229 + ] + }, + { + "teal": 195, + "source": 97, + "pc": [ + 230, + 231, + 232 + ] + }, + { + "teal": 198, + "source": 97, + "pc": [ + 233, + 234, + 235 + ] + }, + { + "teal": 199, + "source": 97, + "pc": [ + 236 + ] + }, + { + "teal": 202, + "source": 97, + "pc": [ + 237, + 238, + 239 + ] + }, + { + "teal": 203, + "source": 97, + "pc": [ + 240 + ] + }, + { + "teal": 206, + "source": 97, + "pc": [ + 241, + 242, + 243 + ] + }, + { + "teal": 207, + "source": 97, + "pc": [ + 244 + ] + }, + { + "teal": 208, + "source": 97, + "pc": [ + 245 + ] + }, + { + "teal": 209, + "source": 97, + "pc": [ + 246 + ] + }, + { + "teal": 210, + "source": 97, + "pc": [ + 247 + ] + }, + { + "teal": 213, + "source": 97, + "errorMessage": "argument 3 (pubKey) for upload must be a address", + "pc": [ + 248 + ] + }, + { + "teal": 216, + "source": 97, + "pc": [ + 249, + 250, + 251 + ] + }, + { + "teal": 217, + "source": 97, + "pc": [ + 252 + ] + }, + { + "teal": 218, + "source": 97, + "pc": [ + 253 + ] + }, + { + "teal": 230, + "source": 97, + "pc": [ + 254, + 255, + 256 + ] + }, + { + "teal": 233, + "source": 97, + "pc": [ + 257 + ] + }, + { + "teal": 237, + "source": 98, + "pc": [ + 258, + 259 + ] + }, + { + "teal": 238, + "source": 98, + "pc": [ + 260, + 261 + ] + }, + { + "teal": 239, + "source": 98, + "pc": [ + 262 + ] + }, + { + "teal": 240, + "source": 98, + "pc": [ + 263 + ] + }, + { + "teal": 244, + "source": 100, + "pc": [ + 264, + 265 + ] + }, + { + "teal": 245, + "source": 100, + "pc": [ + 266, + 267 + ] + }, + { + "teal": 249, + "source": 100, + "pc": [ + 268, + 269 + ] + }, + { + "teal": 250, + "source": 100, + "pc": [ + 270, + 271 + ] + }, + { + "teal": 251, + "source": 100, + "pc": [ + 272 + ] + }, + { + "teal": 252, + "source": 100, + "pc": [ + 273 + ] + }, + { + "teal": 253, + "source": 101, + "pc": [ + 274 + ] + }, + { + "teal": 254, + "source": 26, + "pc": [ + 275 + ] + }, + { + "teal": 255, + "source": 101, + "pc": [ + 276 + ] + }, + { + "teal": 256, + "source": 101, + "pc": [ + 277 + ] + }, + { + "teal": 260, + "source": 100, + "pc": [ + 278, + 279 + ] + }, + { + "teal": 261, + "source": 100, + "pc": [ + 280 + ] + }, + { + "teal": 262, + "source": 100, + "pc": [ + 281 + ] + }, + { + "teal": 263, + "source": 100, + "pc": [ + 282 + ] + }, + { + "teal": 264, + "source": 102, + "pc": [ + 283 + ] + }, + { + "teal": 265, + "source": 102, + "pc": [ + 284, + 285 + ] + }, + { + "teal": 266, + "source": 102, + "pc": [ + 286 + ] + }, + { + "teal": 267, + "source": 102, + "pc": [ + 287 + ] + }, + { + "teal": 268, + "source": 102, + "pc": [ + 288, + 289, + 290 + ] + }, + { + "teal": 269, + "source": 102, + "pc": [ + 291, + 292 + ] + }, + { + "teal": 270, + "source": 100, + "pc": [ + 293, + 294 + ] + }, + { + "teal": 271, + "source": 100, + "pc": [ + 295 + ] + }, + { + "teal": 272, + "source": 100, + "pc": [ + 296 + ] + }, + { + "teal": 273, + "source": 100, + "pc": [ + 297 + ] + }, + { + "teal": 274, + "source": 102, + "pc": [ + 298 + ] + }, + { + "teal": 275, + "source": 102, + "pc": [ + 299 + ] + }, + { + "teal": 276, + "source": 102, + "pc": [ + 300 + ] + }, + { + "teal": 279, + "source": 102, + "pc": [ + 301 + ] + }, + { + "teal": 284, + "source": 104, + "pc": [ + 302, + 303 + ] + }, + { + "teal": 285, + "source": 104, + "pc": [ + 304 + ] + }, + { + "teal": 286, + "source": 104, + "pc": [ + 305 + ] + }, + { + "teal": 287, + "source": 104, + "pc": [ + 306, + 307, + 308 + ] + }, + { + "teal": 292, + "source": 105, + "pc": [ + 309, + 310 + ] + }, + { + "teal": 293, + "source": 105, + "pc": [ + 311 + ] + }, + { + "teal": 294, + "source": 105, + "pc": [ + 312, + 313 + ] + }, + { + "teal": 295, + "source": 100, + "pc": [ + 314, + 315 + ] + }, + { + "teal": 296, + "source": 100, + "pc": [ + 316 + ] + }, + { + "teal": 297, + "source": 100, + "pc": [ + 317 + ] + }, + { + "teal": 298, + "source": 100, + "pc": [ + 318 + ] + }, + { + "teal": 299, + "source": 105, + "pc": [ + 319 + ] + }, + { + "teal": 300, + "source": 105, + "pc": [ + 320 + ] + }, + { + "teal": 301, + "source": 105, + "pc": [ + 321, + 322, + 323 + ] + }, + { + "teal": 302, + "source": 100, + "pc": [ + 324, + 325 + ] + }, + { + "teal": 303, + "source": 100, + "pc": [ + 326, + 327 + ] + }, + { + "teal": 304, + "source": 100, + "pc": [ + 328 + ] + }, + { + "teal": 305, + "source": 100, + "pc": [ + 329 + ] + }, + { + "teal": 306, + "source": 105, + "pc": [ + 330 + ] + }, + { + "teal": 307, + "source": 105, + "pc": [ + 331, + 332, + 333 + ] + }, + { + "teal": 310, + "source": 105, + "pc": [ + 334, + 335 + ] + }, + { + "teal": 313, + "source": 105, + "pc": [ + 336 + ] + }, + { + "teal": 314, + "source": 105, + "pc": [ + 337 + ] + }, + { + "teal": 319, + "source": 108, + "pc": [ + 338, + 339 + ] + }, + { + "teal": 320, + "source": 108, + "pc": [ + 340 + ] + }, + { + "teal": 321, + "source": 108, + "pc": [ + 341, + 342 + ] + }, + { + "teal": 322, + "source": 108, + "pc": [ + 343, + 344 + ] + }, + { + "teal": 323, + "source": 108, + "pc": [ + 345 + ] + }, + { + "teal": 324, + "source": 97, + "pc": [ + 346 + ] + }, + { + "teal": 329, + "source": 117, + "pc": [ + 347, + 348, + 349 + ] + }, + { + "teal": 330, + "source": 117, + "pc": [ + 350 + ] + }, + { + "teal": 331, + "source": 117, + "pc": [ + 351 + ] + }, + { + "teal": 332, + "source": 117, + "pc": [ + 352 + ] + }, + { + "teal": 333, + "source": 117, + "pc": [ + 353 + ] + }, + { + "teal": 336, + "source": 117, + "errorMessage": "argument 0 (pubKey) for finishUpload must be a address", + "pc": [ + 354 + ] + }, + { + "teal": 339, + "source": 117, + "pc": [ + 355, + 356, + 357 + ] + }, + { + "teal": 340, + "source": 117, + "pc": [ + 358 + ] + }, + { + "teal": 341, + "source": 117, + "pc": [ + 359 + ] + }, + { + "teal": 350, + "source": 117, + "pc": [ + 360, + 361, + 362 + ] + }, + { + "teal": 354, + "source": 118, + "pc": [ + 363, + 364 + ] + }, + { + "teal": 355, + "source": 118, + "pc": [ + 365, + 366 + ] + }, + { + "teal": 356, + "source": 118, + "pc": [ + 367 + ] + }, + { + "teal": 357, + "source": 118, + "pc": [ + 368 + ] + }, + { + "teal": 361, + "source": 120, + "pc": [ + 369, + 370 + ] + }, + { + "teal": 362, + "source": 120, + "pc": [ + 371, + 372 + ] + }, + { + "teal": 363, + "source": 120, + "pc": [ + 373, + 374, + 375 + ] + }, + { + "teal": 364, + "source": 120, + "pc": [ + 376 + ] + }, + { + "teal": 365, + "source": 117, + "pc": [ + 377 + ] + }, + { + "teal": 370, + "source": 128, + "pc": [ + 378, + 379, + 380 + ] + }, + { + "teal": 371, + "source": 128, + "pc": [ + 381 + ] + }, + { + "teal": 372, + "source": 128, + "pc": [ + 382 + ] + }, + { + "teal": 373, + "source": 128, + "pc": [ + 383 + ] + }, + { + "teal": 374, + "source": 128, + "pc": [ + 384 + ] + }, + { + "teal": 377, + "source": 128, + "errorMessage": "argument 0 (pubKey) for startDelete must be a address", + "pc": [ + 385 + ] + }, + { + "teal": 380, + "source": 128, + "pc": [ + 386, + 387, + 388 + ] + }, + { + "teal": 381, + "source": 128, + "pc": [ + 389 + ] + }, + { + "teal": 382, + "source": 128, + "pc": [ + 390 + ] + }, + { + "teal": 390, + "source": 128, + "pc": [ + 391, + 392, + 393 + ] + }, + { + "teal": 393, + "source": 128, + "pc": [ + 394 + ] + }, + { + "teal": 397, + "source": 129, + "pc": [ + 395, + 396 + ] + }, + { + "teal": 398, + "source": 129, + "pc": [ + 397, + 398 + ] + }, + { + "teal": 399, + "source": 129, + "pc": [ + 399 + ] + }, + { + "teal": 400, + "source": 129, + "pc": [ + 400 + ] + }, + { + "teal": 404, + "source": 131, + "pc": [ + 401, + 402 + ] + }, + { + "teal": 405, + "source": 131, + "pc": [ + 403, + 404 + ] + }, + { + "teal": 409, + "source": 131, + "pc": [ + 405, + 406 + ] + }, + { + "teal": 410, + "source": 131, + "pc": [ + 407, + 408 + ] + }, + { + "teal": 411, + "source": 131, + "pc": [ + 409 + ] + }, + { + "teal": 412, + "source": 131, + "pc": [ + 410 + ] + }, + { + "teal": 413, + "source": 132, + "pc": [ + 411 + ] + }, + { + "teal": 414, + "source": 29, + "pc": [ + 412 + ] + }, + { + "teal": 415, + "source": 132, + "pc": [ + 413 + ] + }, + { + "teal": 416, + "source": 132, + "pc": [ + 414 + ] + }, + { + "teal": 420, + "source": 131, + "pc": [ + 415, + 416 + ] + }, + { + "teal": 421, + "source": 131, + "pc": [ + 417, + 418 + ] + }, + { + "teal": 422, + "source": 131, + "pc": [ + 419, + 420, + 421 + ] + }, + { + "teal": 423, + "source": 131, + "pc": [ + 422 + ] + }, + { + "teal": 424, + "source": 128, + "pc": [ + 423 + ] + }, + { + "teal": 429, + "source": 143, + "pc": [ + 424, + 425, + 426 + ] + }, + { + "teal": 430, + "source": 143, + "pc": [ + 427 + ] + }, + { + "teal": 433, + "source": 143, + "pc": [ + 428, + 429, + 430 + ] + }, + { + "teal": 434, + "source": 143, + "pc": [ + 431 + ] + }, + { + "teal": 435, + "source": 143, + "pc": [ + 432 + ] + }, + { + "teal": 436, + "source": 143, + "pc": [ + 433 + ] + }, + { + "teal": 437, + "source": 143, + "pc": [ + 434 + ] + }, + { + "teal": 440, + "source": 143, + "errorMessage": "argument 1 (pubKey) for deleteData must be a address", + "pc": [ + 435 + ] + }, + { + "teal": 443, + "source": 143, + "pc": [ + 436, + 437, + 438 + ] + }, + { + "teal": 444, + "source": 143, + "pc": [ + 439 + ] + }, + { + "teal": 445, + "source": 143, + "pc": [ + 440 + ] + }, + { + "teal": 454, + "source": 143, + "pc": [ + 441, + 442, + 443 + ] + }, + { + "teal": 457, + "source": 143, + "pc": [ + 444 + ] + }, + { + "teal": 458, + "source": 143, + "pc": [ + 445 + ] + }, + { + "teal": 462, + "source": 144, + "pc": [ + 446, + 447 + ] + }, + { + "teal": 463, + "source": 144, + "pc": [ + 448, + 449 + ] + }, + { + "teal": 464, + "source": 144, + "pc": [ + 450 + ] + }, + { + "teal": 465, + "source": 144, + "pc": [ + 451 + ] + }, + { + "teal": 469, + "source": 146, + "pc": [ + 452, + 453 + ] + }, + { + "teal": 470, + "source": 146, + "pc": [ + 454, + 455 + ] + }, + { + "teal": 474, + "source": 146, + "pc": [ + 456, + 457 + ] + }, + { + "teal": 475, + "source": 146, + "pc": [ + 458, + 459 + ] + }, + { + "teal": 476, + "source": 146, + "pc": [ + 460 + ] + }, + { + "teal": 477, + "source": 146, + "pc": [ + 461 + ] + }, + { + "teal": 478, + "source": 147, + "pc": [ + 462 + ] + }, + { + "teal": 479, + "source": 32, + "pc": [ + 463, + 464 + ] + }, + { + "teal": 480, + "source": 147, + "pc": [ + 465 + ] + }, + { + "teal": 481, + "source": 147, + "pc": [ + 466 + ] + }, + { + "teal": 485, + "source": 146, + "pc": [ + 467, + 468 + ] + }, + { + "teal": 486, + "source": 146, + "pc": [ + 469 + ] + }, + { + "teal": 487, + "source": 146, + "pc": [ + 470 + ] + }, + { + "teal": 488, + "source": 146, + "pc": [ + 471 + ] + }, + { + "teal": 489, + "source": 148, + "pc": [ + 472 + ] + }, + { + "teal": 490, + "source": 148, + "pc": [ + 473, + 474 + ] + }, + { + "teal": 491, + "source": 148, + "pc": [ + 475 + ] + }, + { + "teal": 492, + "source": 148, + "pc": [ + 476 + ] + }, + { + "teal": 493, + "source": 148, + "pc": [ + 477, + 478, + 479 + ] + }, + { + "teal": 494, + "source": 148, + "pc": [ + 480, + 481 + ] + }, + { + "teal": 495, + "source": 146, + "pc": [ + 482, + 483 + ] + }, + { + "teal": 496, + "source": 146, + "pc": [ + 484 + ] + }, + { + "teal": 497, + "source": 146, + "pc": [ + 485 + ] + }, + { + "teal": 498, + "source": 146, + "pc": [ + 486 + ] + }, + { + "teal": 499, + "source": 148, + "pc": [ + 487 + ] + }, + { + "teal": 500, + "source": 148, + "pc": [ + 488 + ] + }, + { + "teal": 501, + "source": 148, + "pc": [ + 489 + ] + }, + { + "teal": 504, + "source": 148, + "pc": [ + 490 + ] + }, + { + "teal": 509, + "source": 150, + "pc": [ + 491, + 492 + ] + }, + { + "teal": 510, + "source": 146, + "pc": [ + 493, + 494 + ] + }, + { + "teal": 511, + "source": 146, + "pc": [ + 495 + ] + }, + { + "teal": 512, + "source": 146, + "pc": [ + 496 + ] + }, + { + "teal": 513, + "source": 146, + "pc": [ + 497 + ] + }, + { + "teal": 514, + "source": 150, + "pc": [ + 498 + ] + }, + { + "teal": 515, + "source": 150, + "pc": [ + 499 + ] + }, + { + "teal": 516, + "source": 150, + "pc": [ + 500, + 501, + 502 + ] + }, + { + "teal": 521, + "source": 146, + "pc": [ + 503, + 504 + ] + }, + { + "teal": 522, + "source": 146, + "pc": [ + 505, + 506 + ] + }, + { + "teal": 523, + "source": 146, + "pc": [ + 507 + ] + }, + { + "teal": 524, + "source": 146, + "pc": [ + 508 + ] + }, + { + "teal": 525, + "source": 150, + "pc": [ + 509 + ] + }, + { + "teal": 526, + "source": 150, + "pc": [ + 510, + 511 + ] + }, + { + "teal": 527, + "source": 150, + "pc": [ + 512 + ] + }, + { + "teal": 528, + "source": 150, + "pc": [ + 513 + ] + }, + { + "teal": 529, + "source": 150, + "pc": [ + 514 + ] + }, + { + "teal": 530, + "source": 150, + "pc": [ + 515 + ] + }, + { + "teal": 535, + "source": 152, + "pc": [ + 516, + 517 + ] + }, + { + "teal": 536, + "source": 152, + "pc": [ + 518, + 519 + ] + }, + { + "teal": 537, + "source": 152, + "pc": [ + 520 + ] + }, + { + "teal": 538, + "source": 152, + "pc": [ + 521, + 522 + ] + }, + { + "teal": 542, + "source": 154, + "pc": [ + 523, + 524 + ] + }, + { + "teal": 543, + "source": 154, + "pc": [ + 525 + ] + }, + { + "teal": 544, + "source": 154, + "pc": [ + 526 + ] + }, + { + "teal": 549, + "source": 156, + "pc": [ + 527, + 528 + ] + }, + { + "teal": 550, + "source": 146, + "pc": [ + 529, + 530 + ] + }, + { + "teal": 551, + "source": 146, + "pc": [ + 531 + ] + }, + { + "teal": 552, + "source": 146, + "pc": [ + 532 + ] + }, + { + "teal": 553, + "source": 146, + "pc": [ + 533 + ] + }, + { + "teal": 554, + "source": 156, + "pc": [ + 534 + ] + }, + { + "teal": 555, + "source": 156, + "pc": [ + 535 + ] + }, + { + "teal": 556, + "source": 156, + "pc": [ + 536, + 537, + 538 + ] + }, + { + "teal": 561, + "source": 156, + "pc": [ + 539, + 540 + ] + }, + { + "teal": 562, + "source": 156, + "pc": [ + 541 + ] + }, + { + "teal": 563, + "source": 156, + "pc": [ + 542, + 543, + 544 + ] + }, + { + "teal": 568, + "source": 157, + "pc": [ + 545, + 546 + ] + }, + { + "teal": 569, + "source": 157, + "pc": [ + 547, + 548 + ] + }, + { + "teal": 570, + "source": 157, + "pc": [ + 549 + ] + }, + { + "teal": 571, + "source": 146, + "pc": [ + 550, + 551 + ] + }, + { + "teal": 572, + "source": 146, + "pc": [ + 552, + 553 + ] + }, + { + "teal": 573, + "source": 146, + "pc": [ + 554 + ] + }, + { + "teal": 581, + "source": 159, + "pc": [ + 555 + ] + }, + { + "teal": 582, + "source": 159, + "pc": [ + 556 + ] + }, + { + "teal": 583, + "source": 159, + "pc": [ + 557, + 558 + ] + }, + { + "teal": 587, + "source": 160, + "pc": [ + 559, + 560 + ] + }, + { + "teal": 588, + "source": 160, + "pc": [ + 561, + 562 + ] + }, + { + "teal": 589, + "source": 160, + "pc": [ + 563, + 564 + ] + }, + { + "teal": 590, + "source": 160, + "pc": [ + 565 + ] + }, + { + "teal": 591, + "source": 160, + "pc": [ + 566 + ] + }, + { + "teal": 592, + "source": 160, + "pc": [ + 567, + 568 + ] + }, + { + "teal": 596, + "source": 161, + "pc": [ + 569, + 570 + ] + }, + { + "teal": 597, + "source": 161, + "pc": [ + 571, + 572 + ] + }, + { + "teal": 600, + "source": 159, + "pc": [ + 573 + ] + }, + { + "teal": 601, + "source": 159, + "pc": [ + 574, + 575 + ] + }, + { + "teal": 604, + "source": 159, + "pc": [ + 576 + ] + }, + { + "teal": 605, + "source": 143, + "pc": [ + 577 + ] + }, + { + "teal": 610, + "source": 168, + "pc": [ + 578, + 579, + 580 + ] + }, + { + "teal": 611, + "source": 168, + "pc": [ + 581 + ] + }, + { + "teal": 612, + "source": 168, + "pc": [ + 582 + ] + }, + { + "teal": 618, + "source": 168, + "pc": [ + 583, + 584, + 585 + ] + }, + { + "teal": 622, + "source": 169, + "pc": [ + 586, + 587 + ] + }, + { + "teal": 623, + "source": 169, + "pc": [ + 588, + 589 + ] + }, + { + "teal": 624, + "source": 169, + "pc": [ + 590 + ] + }, + { + "teal": 625, + "source": 169, + "pc": [ + 591 + ] + }, + { + "teal": 626, + "source": 168, + "pc": [ + 592 + ] + }, + { + "teal": 631, + "source": 178, + "pc": [ + 593, + 594, + 595 + ] + }, + { + "teal": 632, + "source": 178, + "pc": [ + 596 + ] + }, + { + "teal": 633, + "source": 178, + "pc": [ + 597 + ] + }, + { + "teal": 642, + "source": 178, + "pc": [ + 598, + 599, + 600 + ] + }, + { + "teal": 643, + "source": 178, + "pc": [ + 601 + ] + }, + { + "teal": 646, + "source": 38, + "pc": [ + 602 + ] + }, + { + "teal": 647, + "source": 38, + "pc": [ + 603 + ] + }, + { + "teal": 650, + "source": 38, + "pc": [ + 604, + 605, + 606, + 607, + 608, + 609 + ] + }, + { + "teal": 651, + "source": 38, + "pc": [ + 610, + 611, + 612 + ] + }, + { + "teal": 652, + "source": 38, + "pc": [ + 613, + 614, + 615, + 616 + ] + }, + { + "teal": 655, + "source": 38, + "errorMessage": "this contract does not implement the given ABI method for create NoOp", + "pc": [ + 617 + ] + }, + { + "teal": 658, + "source": 38, + "pc": [ + 618, + 619, + 620, + 621, + 622, + 623 + ] + }, + { + "teal": 659, + "source": 38, + "pc": [ + 624, + 625, + 626, + 627, + 628, + 629 + ] + }, + { + "teal": 660, + "source": 38, + "pc": [ + 630, + 631, + 632, + 633, + 634, + 635 + ] + }, + { + "teal": 661, + "source": 38, + "pc": [ + 636, + 637, + 638, + 639, + 640, + 641 + ] + }, + { + "teal": 662, + "source": 38, + "pc": [ + 642, + 643, + 644, + 645, + 646, + 647 + ] + }, + { + "teal": 663, + "source": 38, + "pc": [ + 648, + 649, + 650, + 651, + 652, + 653 + ] + }, + { + "teal": 664, + "source": 38, + "pc": [ + 654, + 655, + 656 + ] + }, + { + "teal": 665, + "source": 38, + "pc": [ + 657, + 658, + 659, + 660, + 661, + 662, + 663, + 664, + 665, + 666, + 667, + 668, + 669, + 670 + ] + }, + { + "teal": 668, + "source": 38, + "errorMessage": "this contract does not implement the given ABI method for call NoOp", + "pc": [ + 671 + ] + }, + { + "teal": 671, + "source": 38, + "pc": [ + 672, + 673, + 674, + 675, + 676, + 677 + ] + }, + { + "teal": 672, + "source": 38, + "pc": [ + 678, + 679, + 680 + ] + }, + { + "teal": 673, + "source": 38, + "pc": [ + 681, + 682, + 683, + 684 + ] + }, + { + "teal": 676, + "source": 38, + "errorMessage": "this contract does not implement the given ABI method for call UpdateApplication", + "pc": [ + 685 + ] + } +] \ No newline at end of file diff --git a/reference_contract/package-lock.json b/reference_contract/package-lock.json index 01a059c..34eb441 100644 --- a/reference_contract/package-lock.json +++ b/reference_contract/package-lock.json @@ -10,7 +10,7 @@ "license": "MIT", "dependencies": { "@algorandfoundation/algokit-utils": "^5.1.3", - "@algorandfoundation/tealscript": "^0.51.1", + "@algorandfoundation/tealscript": "^0.96.0", "algosdk": "^2.6.0" }, "devDependencies": { @@ -71,14 +71,18 @@ } }, "node_modules/@algorandfoundation/tealscript": { - "version": "0.51.1", - "resolved": "https://registry.npmjs.org/@algorandfoundation/tealscript/-/tealscript-0.51.1.tgz", - "integrity": "sha512-VM1orcyoy1VqzwD2jKNxbef6elq94KneH5SuXYM8FdBsFEqD7STukIWGWBQ/5om/LbtomvhwHx7GrWx6m+HjWA==", + "version": "0.96.0", + "resolved": "https://registry.npmjs.org/@algorandfoundation/tealscript/-/tealscript-0.96.0.tgz", + "integrity": "sha512-NKL+IpTpYpwYUHrVxMl/YQ0y+3+hPnShrPaSfy0fc68ftnhHuP7gIkFiwM4kuJvBcc3+StXY7dqb0tpQh3o0wg==", "dependencies": { "@microsoft/tsdoc": "^0.14.2", + "@playwright/test": "^1.40.1", "argparse": "^2.0.1", "dotenv": "^16.3.1", + "glob": "^10.3.10", + "js-sha512": "^0.8.0", "node-fetch": "2", + "polytype": "^0.17.0", "source-map": "^0.7.4", "ts-morph": "^20.0.0", "typescript": "^4.9.3", @@ -88,6 +92,50 @@ "tealscript": "dist/bin/tealscript.js" } }, + "node_modules/@algorandfoundation/tealscript/node_modules/brace-expansion": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", + "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", + "dependencies": { + "balanced-match": "^1.0.0" + } + }, + "node_modules/@algorandfoundation/tealscript/node_modules/glob": { + "version": "10.4.2", + "resolved": "https://registry.npmjs.org/glob/-/glob-10.4.2.tgz", + "integrity": "sha512-GwMlUF6PkPo3Gk21UxkCohOv0PLcIXVtKyLlpEI28R/cO/4eNOdmLk3CMW1wROV/WR/EsZOWAfBbBOqYvs88/w==", + "dependencies": { + "foreground-child": "^3.1.0", + "jackspeak": "^3.1.2", + "minimatch": "^9.0.4", + "minipass": "^7.1.2", + "package-json-from-dist": "^1.0.0", + "path-scurry": "^1.11.1" + }, + "bin": { + "glob": "dist/esm/bin.mjs" + }, + "engines": { + "node": ">=16 || 14 >=14.18" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/@algorandfoundation/tealscript/node_modules/minimatch": { + "version": "9.0.4", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.4.tgz", + "integrity": "sha512-KqWh+VchfxcMNRAJjj2tnsSJdNbHsVgnkBhTNrW7AjVo6OvLtxw8zfT9oLw1JSohlFzJ8jCoTgaoXvJ+kHt6fw==", + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "engines": { + "node": ">=16 || 14 >=14.17" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, "node_modules/@algorandfoundation/tealscript/node_modules/source-map": { "version": "0.7.4", "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.7.4.tgz", @@ -810,6 +858,95 @@ "dev": true, "license": "BSD-3-Clause" }, + "node_modules/@isaacs/cliui": { + "version": "8.0.2", + "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz", + "integrity": "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==", + "dependencies": { + "string-width": "^5.1.2", + "string-width-cjs": "npm:string-width@^4.2.0", + "strip-ansi": "^7.0.1", + "strip-ansi-cjs": "npm:strip-ansi@^6.0.1", + "wrap-ansi": "^8.1.0", + "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/@isaacs/cliui/node_modules/ansi-regex": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.0.1.tgz", + "integrity": "sha512-n5M855fKb2SsfMIiFFoVrABHJC8QtHwVx+mHWP3QcEqBHYienj5dHSgjbxtC0WEZXYt4wcD6zrQElDPhFuZgfA==", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-regex?sponsor=1" + } + }, + "node_modules/@isaacs/cliui/node_modules/ansi-styles": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.1.tgz", + "integrity": "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/@isaacs/cliui/node_modules/emoji-regex": { + "version": "9.2.2", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz", + "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==" + }, + "node_modules/@isaacs/cliui/node_modules/string-width": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz", + "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==", + "dependencies": { + "eastasianwidth": "^0.2.0", + "emoji-regex": "^9.2.2", + "strip-ansi": "^7.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/@isaacs/cliui/node_modules/strip-ansi": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz", + "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==", + "dependencies": { + "ansi-regex": "^6.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/strip-ansi?sponsor=1" + } + }, + "node_modules/@isaacs/cliui/node_modules/wrap-ansi": { + "version": "8.1.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz", + "integrity": "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==", + "dependencies": { + "ansi-styles": "^6.1.0", + "string-width": "^5.0.1", + "strip-ansi": "^7.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, "node_modules/@istanbuljs/load-nyc-config": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/@istanbuljs/load-nyc-config/-/load-nyc-config-1.1.0.tgz", @@ -1236,6 +1373,29 @@ "node": ">= 8" } }, + "node_modules/@pkgjs/parseargs": { + "version": "0.11.0", + "resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz", + "integrity": "sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==", + "optional": true, + "engines": { + "node": ">=14" + } + }, + "node_modules/@playwright/test": { + "version": "1.44.1", + "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.44.1.tgz", + "integrity": "sha512-1hZ4TNvD5z9VuhNJ/walIjvMVvYkZKf71axoF/uiAqpntQJXpG64dlXhoDXE3OczPuTuvjf/M5KWFg5VAVUS3Q==", + "dependencies": { + "playwright": "1.44.1" + }, + "bin": { + "playwright": "cli.js" + }, + "engines": { + "node": ">=16" + } + }, "node_modules/@sinclair/typebox": { "version": "0.25.24", "dev": true, @@ -1776,7 +1936,6 @@ "version": "5.0.1", "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", - "dev": true, "license": "MIT", "engines": { "node": ">=8" @@ -1786,7 +1945,6 @@ "version": "4.3.0", "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", - "dev": true, "license": "MIT", "dependencies": { "color-convert": "^2.0.1" @@ -2340,7 +2498,6 @@ "version": "2.0.1", "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", - "dev": true, "license": "MIT", "dependencies": { "color-name": "~1.1.4" @@ -2353,7 +2510,6 @@ "version": "1.1.4", "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", - "dev": true, "license": "MIT" }, "node_modules/commander": { @@ -2403,7 +2559,6 @@ "version": "7.0.3", "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz", "integrity": "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==", - "dev": true, "license": "MIT", "dependencies": { "path-key": "^3.1.0", @@ -2529,16 +2684,21 @@ } }, "node_modules/dotenv": { - "version": "16.3.1", - "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.3.1.tgz", - "integrity": "sha512-IPzF4w4/Rd94bA9imS68tZBaYyBWSCE47V1RGuMrB94iyTOIEwRmVL2x/4An+6mETpLrKJ5hQkB8W4kFAadeIQ==", + "version": "16.4.5", + "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.4.5.tgz", + "integrity": "sha512-ZmdL2rui+eB2YwhsWzjInR8LldtZHGDoQ1ugH85ppHKwpUHL7j7rN0Ti9NCnGiQbhaZ11FpR+7ao1dNsmduNUg==", "engines": { "node": ">=12" }, "funding": { - "url": "https://github.com/motdotla/dotenv?sponsor=1" + "url": "https://dotenvx.com" } }, + "node_modules/eastasianwidth": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz", + "integrity": "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==" + }, "node_modules/electron-to-chromium": { "version": "1.4.435", "dev": true, @@ -2561,7 +2721,6 @@ "version": "8.0.0", "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", - "dev": true, "license": "MIT" }, "node_modules/error-ex": { @@ -3229,6 +3388,32 @@ "is-callable": "^1.1.3" } }, + "node_modules/foreground-child": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.2.1.tgz", + "integrity": "sha512-PXUUyLqrR2XCWICfv6ukppP96sdFwWbNEnfEMt7jNsISjMsvaLNinAHNDYyvkyU+SZG2BTSbT5NjG+vZslfGTA==", + "dependencies": { + "cross-spawn": "^7.0.0", + "signal-exit": "^4.0.1" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/foreground-child/node_modules/signal-exit": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz", + "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==", + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, "node_modules/fs.realpath": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", @@ -3240,7 +3425,6 @@ "version": "2.3.2", "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz", "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==", - "dev": true, "license": "MIT", "optional": true, "os": [ @@ -3826,7 +4010,6 @@ "version": "3.0.0", "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", - "dev": true, "license": "MIT", "engines": { "node": ">=8" @@ -4012,7 +4195,6 @@ "version": "2.0.0", "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", - "dev": true, "license": "ISC" }, "node_modules/istanbul-lib-coverage": { @@ -4082,6 +4264,23 @@ "node": ">=8" } }, + "node_modules/jackspeak": { + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-3.4.0.tgz", + "integrity": "sha512-JVYhQnN59LVPFCEcVa2C3CrEKYacvjRfqIQl+h8oi91aLYQVWRYbxjPcv1bUiUy/kLmQaANrYfNMCO3kuEDHfw==", + "dependencies": { + "@isaacs/cliui": "^8.0.2" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + }, + "optionalDependencies": { + "@pkgjs/parseargs": "^0.11.0" + } + }, "node_modules/jest": { "version": "29.5.0", "dev": true, @@ -4925,6 +5124,14 @@ "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/minipass": { + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz", + "integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==", + "engines": { + "node": ">=16 || 14 >=14.17" + } + }, "node_modules/mkdirp": { "version": "2.1.6", "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-2.1.6.tgz", @@ -5194,6 +5401,11 @@ "node": ">=6" } }, + "node_modules/package-json-from-dist": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/package-json-from-dist/-/package-json-from-dist-1.0.0.tgz", + "integrity": "sha512-dATvCeZN/8wQsGywez1mzHtTlP22H8OEfPrVMLNr4/eGa+ijtLn/6M5f0dY8UKNrC2O9UCU6SSoG3qRKnt7STw==" + }, "node_modules/param-case": { "version": "3.0.4", "resolved": "https://registry.npmjs.org/param-case/-/param-case-3.0.4.tgz", @@ -5288,7 +5500,6 @@ "version": "3.1.1", "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", - "dev": true, "license": "MIT", "engines": { "node": ">=8" @@ -5301,6 +5512,29 @@ "dev": true, "license": "MIT" }, + "node_modules/path-scurry": { + "version": "1.11.1", + "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-1.11.1.tgz", + "integrity": "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==", + "dependencies": { + "lru-cache": "^10.2.0", + "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0" + }, + "engines": { + "node": ">=16 || 14 >=14.18" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/path-scurry/node_modules/lru-cache": { + "version": "10.2.2", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.2.2.tgz", + "integrity": "sha512-9hp3Vp2/hFQUiIwKo8XCeFVnrg8Pk3TYNPIR7tJADKi5YfcF7vEaK7avFHTlSy3kOKYaJQaalfEo6YuXdceBOQ==", + "engines": { + "node": "14 || >=16.14" + } + }, "node_modules/path-type": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz", @@ -5353,6 +5587,42 @@ "node": ">=8" } }, + "node_modules/playwright": { + "version": "1.44.1", + "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.44.1.tgz", + "integrity": "sha512-qr/0UJ5CFAtloI3avF95Y0L1xQo6r3LQArLIg/z/PoGJ6xa+EwzrwO5lpNr/09STxdHuUoP2mvuELJS+hLdtgg==", + "dependencies": { + "playwright-core": "1.44.1" + }, + "bin": { + "playwright": "cli.js" + }, + "engines": { + "node": ">=16" + }, + "optionalDependencies": { + "fsevents": "2.3.2" + } + }, + "node_modules/playwright-core": { + "version": "1.44.1", + "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.44.1.tgz", + "integrity": "sha512-wh0JWtYTrhv1+OSsLPgFzGzt67Y7BE/ZS3jEqgGBlp2ppp1ZDj8c+9IARNW4dwf1poq5MgHreEM2KV/GuR4cFA==", + "bin": { + "playwright-core": "cli.js" + }, + "engines": { + "node": ">=16" + } + }, + "node_modules/polytype": { + "version": "0.17.0", + "resolved": "https://registry.npmjs.org/polytype/-/polytype-0.17.0.tgz", + "integrity": "sha512-Q1y07MZqHPlGRJs8qI8bnxrQs+W3r24v25cmhbQV/lC9VNNtd+smi/2m3CUHNBDTfLtl+6SpA0EsL/J1oVsEag==", + "engines": { + "node": ">=16.0.0" + } + }, "node_modules/prelude-ls": { "version": "1.2.1", "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz", @@ -5620,7 +5890,6 @@ "version": "2.0.0", "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", - "dev": true, "license": "MIT", "dependencies": { "shebang-regex": "^3.0.0" @@ -5633,7 +5902,6 @@ "version": "3.0.0", "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", - "dev": true, "license": "MIT", "engines": { "node": ">=8" @@ -5758,7 +6026,6 @@ "version": "4.2.3", "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", - "dev": true, "license": "MIT", "dependencies": { "emoji-regex": "^8.0.0", @@ -5769,6 +6036,20 @@ "node": ">=8" } }, + "node_modules/string-width-cjs": { + "name": "string-width", + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=8" + } + }, "node_modules/string.prototype.trim": { "version": "1.2.7", "resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.2.7.tgz", @@ -5821,7 +6102,6 @@ "version": "6.0.1", "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", - "dev": true, "license": "MIT", "dependencies": { "ansi-regex": "^5.0.1" @@ -5830,6 +6110,18 @@ "node": ">=8" } }, + "node_modules/strip-ansi-cjs": { + "name": "strip-ansi", + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, "node_modules/strip-bom": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", @@ -5943,8 +6235,7 @@ "node_modules/tr46": { "version": "0.0.3", "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz", - "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==", - "license": "MIT" + "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==" }, "node_modules/ts-jest": { "version": "29.1.0", @@ -6245,14 +6536,12 @@ "node_modules/webidl-conversions": { "version": "3.0.1", "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz", - "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==", - "license": "BSD-2-Clause" + "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==" }, "node_modules/whatwg-url": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz", "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==", - "license": "MIT", "dependencies": { "tr46": "~0.0.3", "webidl-conversions": "^3.0.0" @@ -6262,7 +6551,6 @@ "version": "2.0.2", "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", - "dev": true, "license": "ISC", "dependencies": { "isexe": "^2.0.0" @@ -6336,6 +6624,23 @@ "url": "https://github.com/chalk/wrap-ansi?sponsor=1" } }, + "node_modules/wrap-ansi-cjs": { + "name": "wrap-ansi", + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", + "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", + "dependencies": { + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, "node_modules/wrappy": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", @@ -6450,20 +6755,53 @@ } }, "@algorandfoundation/tealscript": { - "version": "0.51.1", - "resolved": "https://registry.npmjs.org/@algorandfoundation/tealscript/-/tealscript-0.51.1.tgz", - "integrity": "sha512-VM1orcyoy1VqzwD2jKNxbef6elq94KneH5SuXYM8FdBsFEqD7STukIWGWBQ/5om/LbtomvhwHx7GrWx6m+HjWA==", + "version": "0.96.0", + "resolved": "https://registry.npmjs.org/@algorandfoundation/tealscript/-/tealscript-0.96.0.tgz", + "integrity": "sha512-NKL+IpTpYpwYUHrVxMl/YQ0y+3+hPnShrPaSfy0fc68ftnhHuP7gIkFiwM4kuJvBcc3+StXY7dqb0tpQh3o0wg==", "requires": { "@microsoft/tsdoc": "^0.14.2", + "@playwright/test": "^1.40.1", "argparse": "^2.0.1", "dotenv": "^16.3.1", + "glob": "^10.3.10", + "js-sha512": "^0.8.0", "node-fetch": "2", + "polytype": "^0.17.0", "source-map": "^0.7.4", "ts-morph": "^20.0.0", "typescript": "^4.9.3", "vlq": "^2.0.4" }, "dependencies": { + "brace-expansion": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", + "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", + "requires": { + "balanced-match": "^1.0.0" + } + }, + "glob": { + "version": "10.4.2", + "resolved": "https://registry.npmjs.org/glob/-/glob-10.4.2.tgz", + "integrity": "sha512-GwMlUF6PkPo3Gk21UxkCohOv0PLcIXVtKyLlpEI28R/cO/4eNOdmLk3CMW1wROV/WR/EsZOWAfBbBOqYvs88/w==", + "requires": { + "foreground-child": "^3.1.0", + "jackspeak": "^3.1.2", + "minimatch": "^9.0.4", + "minipass": "^7.1.2", + "package-json-from-dist": "^1.0.0", + "path-scurry": "^1.11.1" + } + }, + "minimatch": { + "version": "9.0.4", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.4.tgz", + "integrity": "sha512-KqWh+VchfxcMNRAJjj2tnsSJdNbHsVgnkBhTNrW7AjVo6OvLtxw8zfT9oLw1JSohlFzJ8jCoTgaoXvJ+kHt6fw==", + "requires": { + "brace-expansion": "^2.0.1" + } + }, "source-map": { "version": "0.7.4", "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.7.4.tgz", @@ -6953,6 +7291,64 @@ "integrity": "sha512-ZnQMnLV4e7hDlUvw8H+U8ASL02SS2Gn6+9Ac3wGGLIe7+je2AeAOxPY+izIPJDfFDb7eDjev0Us8MO1iFRN8hA==", "dev": true }, + "@isaacs/cliui": { + "version": "8.0.2", + "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz", + "integrity": "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==", + "requires": { + "string-width": "^5.1.2", + "string-width-cjs": "npm:string-width@^4.2.0", + "strip-ansi": "^7.0.1", + "strip-ansi-cjs": "npm:strip-ansi@^6.0.1", + "wrap-ansi": "^8.1.0", + "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0" + }, + "dependencies": { + "ansi-regex": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.0.1.tgz", + "integrity": "sha512-n5M855fKb2SsfMIiFFoVrABHJC8QtHwVx+mHWP3QcEqBHYienj5dHSgjbxtC0WEZXYt4wcD6zrQElDPhFuZgfA==" + }, + "ansi-styles": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.1.tgz", + "integrity": "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==" + }, + "emoji-regex": { + "version": "9.2.2", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz", + "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==" + }, + "string-width": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz", + "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==", + "requires": { + "eastasianwidth": "^0.2.0", + "emoji-regex": "^9.2.2", + "strip-ansi": "^7.0.1" + } + }, + "strip-ansi": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz", + "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==", + "requires": { + "ansi-regex": "^6.0.1" + } + }, + "wrap-ansi": { + "version": "8.1.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz", + "integrity": "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==", + "requires": { + "ansi-styles": "^6.1.0", + "string-width": "^5.0.1", + "strip-ansi": "^7.0.1" + } + } + } + }, "@istanbuljs/load-nyc-config": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/@istanbuljs/load-nyc-config/-/load-nyc-config-1.1.0.tgz", @@ -7268,6 +7664,20 @@ "fastq": "^1.6.0" } }, + "@pkgjs/parseargs": { + "version": "0.11.0", + "resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz", + "integrity": "sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==", + "optional": true + }, + "@playwright/test": { + "version": "1.44.1", + "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.44.1.tgz", + "integrity": "sha512-1hZ4TNvD5z9VuhNJ/walIjvMVvYkZKf71axoF/uiAqpntQJXpG64dlXhoDXE3OczPuTuvjf/M5KWFg5VAVUS3Q==", + "requires": { + "playwright": "1.44.1" + } + }, "@sinclair/typebox": { "version": "0.25.24", "dev": true @@ -7630,14 +8040,12 @@ "ansi-regex": { "version": "5.0.1", "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", - "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", - "dev": true + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==" }, "ansi-styles": { "version": "4.3.0", "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", - "dev": true, "requires": { "color-convert": "^2.0.1" } @@ -7985,7 +8393,6 @@ "version": "2.0.1", "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", - "dev": true, "requires": { "color-name": "~1.1.4" } @@ -7993,8 +8400,7 @@ "color-name": { "version": "1.1.4", "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", - "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", - "dev": true + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" }, "commander": { "version": "10.0.1", @@ -8035,7 +8441,6 @@ "version": "7.0.3", "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz", "integrity": "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==", - "dev": true, "requires": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", @@ -8118,9 +8523,14 @@ } }, "dotenv": { - "version": "16.3.1", - "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.3.1.tgz", - "integrity": "sha512-IPzF4w4/Rd94bA9imS68tZBaYyBWSCE47V1RGuMrB94iyTOIEwRmVL2x/4An+6mETpLrKJ5hQkB8W4kFAadeIQ==" + "version": "16.4.5", + "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.4.5.tgz", + "integrity": "sha512-ZmdL2rui+eB2YwhsWzjInR8LldtZHGDoQ1ugH85ppHKwpUHL7j7rN0Ti9NCnGiQbhaZ11FpR+7ao1dNsmduNUg==" + }, + "eastasianwidth": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz", + "integrity": "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==" }, "electron-to-chromium": { "version": "1.4.435", @@ -8135,8 +8545,7 @@ "emoji-regex": { "version": "8.0.0", "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", - "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", - "dev": true + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==" }, "error-ex": { "version": "1.3.2", @@ -8619,6 +9028,22 @@ "is-callable": "^1.1.3" } }, + "foreground-child": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.2.1.tgz", + "integrity": "sha512-PXUUyLqrR2XCWICfv6ukppP96sdFwWbNEnfEMt7jNsISjMsvaLNinAHNDYyvkyU+SZG2BTSbT5NjG+vZslfGTA==", + "requires": { + "cross-spawn": "^7.0.0", + "signal-exit": "^4.0.1" + }, + "dependencies": { + "signal-exit": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz", + "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==" + } + } + }, "fs.realpath": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", @@ -8629,7 +9054,6 @@ "version": "2.3.2", "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz", "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==", - "dev": true, "optional": true }, "function-bind": { @@ -8996,8 +9420,7 @@ "is-fullwidth-code-point": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", - "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", - "dev": true + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==" }, "is-generator-fn": { "version": "2.1.0", @@ -9105,8 +9528,7 @@ "isexe": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", - "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", - "dev": true + "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==" }, "istanbul-lib-coverage": { "version": "3.2.0", @@ -9155,6 +9577,15 @@ "istanbul-lib-report": "^3.0.0" } }, + "jackspeak": { + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-3.4.0.tgz", + "integrity": "sha512-JVYhQnN59LVPFCEcVa2C3CrEKYacvjRfqIQl+h8oi91aLYQVWRYbxjPcv1bUiUy/kLmQaANrYfNMCO3kuEDHfw==", + "requires": { + "@isaacs/cliui": "^8.0.2", + "@pkgjs/parseargs": "^0.11.0" + } + }, "jest": { "version": "29.5.0", "dev": true, @@ -9755,6 +10186,11 @@ "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==", "dev": true }, + "minipass": { + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz", + "integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==" + }, "mkdirp": { "version": "2.1.6", "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-2.1.6.tgz", @@ -9932,6 +10368,11 @@ "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==", "dev": true }, + "package-json-from-dist": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/package-json-from-dist/-/package-json-from-dist-1.0.0.tgz", + "integrity": "sha512-dATvCeZN/8wQsGywez1mzHtTlP22H8OEfPrVMLNr4/eGa+ijtLn/6M5f0dY8UKNrC2O9UCU6SSoG3qRKnt7STw==" + }, "param-case": { "version": "3.0.4", "resolved": "https://registry.npmjs.org/param-case/-/param-case-3.0.4.tgz", @@ -10003,8 +10444,7 @@ "path-key": { "version": "3.1.1", "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", - "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", - "dev": true + "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==" }, "path-parse": { "version": "1.0.7", @@ -10012,6 +10452,22 @@ "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", "dev": true }, + "path-scurry": { + "version": "1.11.1", + "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-1.11.1.tgz", + "integrity": "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==", + "requires": { + "lru-cache": "^10.2.0", + "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0" + }, + "dependencies": { + "lru-cache": { + "version": "10.2.2", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.2.2.tgz", + "integrity": "sha512-9hp3Vp2/hFQUiIwKo8XCeFVnrg8Pk3TYNPIR7tJADKi5YfcF7vEaK7avFHTlSy3kOKYaJQaalfEo6YuXdceBOQ==" + } + } + }, "path-type": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz", @@ -10044,6 +10500,25 @@ "find-up": "^4.0.0" } }, + "playwright": { + "version": "1.44.1", + "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.44.1.tgz", + "integrity": "sha512-qr/0UJ5CFAtloI3avF95Y0L1xQo6r3LQArLIg/z/PoGJ6xa+EwzrwO5lpNr/09STxdHuUoP2mvuELJS+hLdtgg==", + "requires": { + "fsevents": "2.3.2", + "playwright-core": "1.44.1" + } + }, + "playwright-core": { + "version": "1.44.1", + "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.44.1.tgz", + "integrity": "sha512-wh0JWtYTrhv1+OSsLPgFzGzt67Y7BE/ZS3jEqgGBlp2ppp1ZDj8c+9IARNW4dwf1poq5MgHreEM2KV/GuR4cFA==" + }, + "polytype": { + "version": "0.17.0", + "resolved": "https://registry.npmjs.org/polytype/-/polytype-0.17.0.tgz", + "integrity": "sha512-Q1y07MZqHPlGRJs8qI8bnxrQs+W3r24v25cmhbQV/lC9VNNtd+smi/2m3CUHNBDTfLtl+6SpA0EsL/J1oVsEag==" + }, "prelude-ls": { "version": "1.2.1", "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz", @@ -10197,7 +10672,6 @@ "version": "2.0.0", "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", - "dev": true, "requires": { "shebang-regex": "^3.0.0" } @@ -10205,8 +10679,7 @@ "shebang-regex": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", - "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", - "dev": true + "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==" }, "side-channel": { "version": "1.0.4", @@ -10300,7 +10773,16 @@ "version": "4.2.3", "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", - "dev": true, + "requires": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + } + }, + "string-width-cjs": { + "version": "npm:string-width@4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", "requires": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", @@ -10344,7 +10826,14 @@ "version": "6.0.1", "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", - "dev": true, + "requires": { + "ansi-regex": "^5.0.1" + } + }, + "strip-ansi-cjs": { + "version": "npm:strip-ansi@6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", "requires": { "ansi-regex": "^5.0.1" } @@ -10633,7 +11122,6 @@ "version": "2.0.2", "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", - "dev": true, "requires": { "isexe": "^2.0.0" } @@ -10678,6 +11166,16 @@ "strip-ansi": "^6.0.0" } }, + "wrap-ansi-cjs": { + "version": "npm:wrap-ansi@7.0.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", + "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", + "requires": { + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" + } + }, "wrappy": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", diff --git a/reference_contract/package.json b/reference_contract/package.json index 2e05417..2afa37b 100644 --- a/reference_contract/package.json +++ b/reference_contract/package.json @@ -12,7 +12,7 @@ }, "dependencies": { "@algorandfoundation/algokit-utils": "^5.1.3", - "@algorandfoundation/tealscript": "^0.51.1", + "@algorandfoundation/tealscript": "^0.96.0", "algosdk": "^2.6.0" }, "devDependencies": { From 13389bdbde02d4c39ae9a8a17f9aac4806ccdefa Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Wed, 19 Jun 2024 13:33:12 -0400 Subject: [PATCH 4/9] update tests --- reference_contract/__test__/algo-did.test.ts | 34 +++++++++++--------- reference_contract/src/index.ts | 27 ++++++++++------ 2 files changed, 35 insertions(+), 26 deletions(-) diff --git a/reference_contract/__test__/algo-did.test.ts b/reference_contract/__test__/algo-did.test.ts index 2bdfa75..60854b5 100644 --- a/reference_contract/__test__/algo-did.test.ts +++ b/reference_contract/__test__/algo-did.test.ts @@ -12,7 +12,7 @@ import { resolveDID, uploadDIDDocument, deleteDIDDocument, updateDIDDocument, } from '../src/index'; -jest.setTimeout(20000) +jest.setTimeout(20000); describe('Algorand DID', () => { /** @@ -68,39 +68,41 @@ describe('Algorand DID', () => { describe('uploadDIDDocument and Resolve', () => { it('(LARGE) DIDocument upload and resolve', async () => { const { appId } = await appClient.getAppReference(); - const addr = algosdk.encodeAddress(bigDataUserKey); + const pubkeyHex = Buffer.from(bigDataUserKey).toString('hex'); // Large upload await uploadDIDDocument(bigData, Number(appId), bigDataUserKey, sender, algodClient); // Reconstruct DID from several boxes - const resolvedData: Buffer = await resolveDID(`did:algo:${addr}-${appId}`, algodClient); - expect(resolvedData.toString('hex')).toEqual(bigData.toString('hex')) - }) + const resolvedData: Buffer = await resolveDID(`did:algo:custom:app:${appId}:${pubkeyHex}`, algodClient); + expect(resolvedData.toString('hex')).toEqual(bigData.toString('hex')); + }); it('(SMALL) DIDocument upload and resolve', async () => { const { appId } = await appClient.getAppReference(); - const addr = algosdk.encodeAddress(smallDataUserKey); + const pubkeyHex = Buffer.from(smallDataUserKey).toString('hex'); // Small upload - await uploadDIDDocument(Buffer.from(JSON.stringify(smallJSONObject)), + await uploadDIDDocument( + Buffer.from(JSON.stringify(smallJSONObject)), Number(appId), smallDataUserKey, sender, - algodClient); + algodClient, + ); // Reconstruct DID from several boxes - const resolvedData: Buffer = await resolveDID(`did:algo:${addr}-${appId}`, algodClient); - expect(resolvedData.toString('hex')).toEqual(Buffer.from(JSON.stringify(smallJSONObject)).toString('hex')) - }) - }) + const resolvedData: Buffer = await resolveDID(`did:algo:custom:app:${appId}:${pubkeyHex}`, algodClient); + expect(resolvedData.toString('hex')).toEqual(Buffer.from(JSON.stringify(smallJSONObject)).toString('hex')); + }); + }); describe('deleteDIDDocument', () => { const deleteDIDDocumentTest = async (userKey: Uint8Array) => { await deleteDIDDocument(appId, userKey, sender, algodClient); + const pubkeyHex = Buffer.from(userKey).toString('hex'); - const addr = algosdk.encodeAddress(userKey); - await expect(resolveDID(`did:algo:${addr}-${appId}`, algodClient)).rejects.toThrow(); + await expect(resolveDID(`did:algo:custom:app:${appId}:${pubkeyHex}`, algodClient)).rejects.toThrow(); }; it('deletes big (multi-box) data', async () => { @@ -142,8 +144,8 @@ describe('Algorand DID', () => { algodClient, ); - const addr = algosdk.encodeAddress(updateDataUserKey); - const resolvedData = await resolveDID(`did:algo:${addr}-${appId}`, algodClient); + const pubkeyHex = Buffer.from(updateDataUserKey).toString('hex'); + const resolvedData = await resolveDID(`did:algo:custom:app:${appId}:${pubkeyHex}`, algodClient); expect(resolvedData.toString()).toEqual(JSON.stringify(smallJSONObject)); }); diff --git a/reference_contract/src/index.ts b/reference_contract/src/index.ts index b598bf2..af13588 100644 --- a/reference_contract/src/index.ts +++ b/reference_contract/src/index.ts @@ -22,25 +22,32 @@ export type Metadata = {start: bigint, end: bigint, status: bigint, endSize: big export async function resolveDID(did: string, algodClient: algosdk.Algodv2): Promise { const splitDid = did.split(':'); - if (splitDid[0] !== 'did') throw new Error(`Invalid protocol. Expected 'did', got ${splitDid[0]}`); - if (splitDid[1] !== 'algo') throw new Error(`Invalid DID method. Expected 'algod', got ${splitDid[1]}`); + const idxOffset = splitDid.length === 6 ? 0 : 1; - const splitID = splitDid[2].split('-'); + if (splitDid[0] !== 'did') { + throw new Error(`invalid protocol, expected 'did', got ${splitDid[0]}`); + } + if (splitDid[1] !== 'algo') { + throw new Error(`invalid DID method, expected 'algo', got ${splitDid[1]}`); + } - let pubKey: Uint8Array; - try { - pubKey = algosdk.decodeAddress(splitID[0]).publicKey; - } catch (e) { - throw new Error(`Invalid public key. Expected Algorand address, got ${splitID[0]}`); + const nameSpace = splitDid[3 - idxOffset]; + + if (nameSpace !== 'app') { + throw new Error(`invalid namespace, expected 'app', got ${nameSpace}`); } + const pubKey = Buffer.from(splitDid[5 - idxOffset], 'hex'); + let appID: bigint; try { - appID = BigInt(splitID[1]); + appID = BigInt(splitDid[4 - idxOffset]); algosdk.encodeUint64(appID); } catch (e) { - throw new Error(`Invalid app ID. Expected uint64, got ${splitID[1]}`); + throw new Error( + `invalid app ID, expected uint64, got ${splitDid[4 - idxOffset]}`, + ); } const appClient = new ApplicationClient({ From da6cba106e816dddc261b4814b0a38e1799dbe9d Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Wed, 19 Jun 2024 13:38:45 -0400 Subject: [PATCH 5/9] update cli contracs dir, use actual did:algo document --- client/internal/contracts/AlgoDID.abi.json | 2 +- .../internal/contracts/AlgoDID.approval.teal | 520 +- client/internal/contracts/AlgoDID.arc32.json | 214 + client/internal/contracts/AlgoDID.arc4.json | 134 + .../contracts/AlgoDID.arc56_draft.json | 3189 ++++++++ client/internal/contracts/AlgoDID.clear.teal | 3 +- client/internal/contracts/AlgoDID.json | 4 +- .../internal/contracts/AlgoDID.src_map.json | 7288 +++++------------ reference_contract/__test__/DIDocument.json | 110 +- reference_contract/package.json | 2 +- 10 files changed, 6047 insertions(+), 5419 deletions(-) create mode 100644 client/internal/contracts/AlgoDID.arc32.json create mode 100644 client/internal/contracts/AlgoDID.arc4.json create mode 100644 client/internal/contracts/AlgoDID.arc56_draft.json diff --git a/client/internal/contracts/AlgoDID.abi.json b/client/internal/contracts/AlgoDID.abi.json index 0b24dea..a62273e 100644 --- a/client/internal/contracts/AlgoDID.abi.json +++ b/client/internal/contracts/AlgoDID.abi.json @@ -124,7 +124,7 @@ { "name": "dummy", "args": [], - "desc": "Dummy function to add extra box references for deleteData.Boxes are 32k, but a single app call can only include enough references to read/write 8kat a time. Thus when a box is deleted, we need to add additional dummy calls with boxreferences to increase the total read/write budget to 32k.", + "desc": "Dummy function to add extra box references for deleteData.Boxes are 32k, but a single app call can only inlcude enough references to read/write 8kat a time. Thus when a box is deleted, we need to add additional dummy calls with boxreferences to increase the total read/write budget to 32k.", "returns": { "type": "void", "desc": "" diff --git a/client/internal/contracts/AlgoDID.approval.teal b/client/internal/contracts/AlgoDID.approval.teal index 3af3889..a9cdc96 100644 --- a/client/internal/contracts/AlgoDID.approval.teal +++ b/client/internal/contracts/AlgoDID.approval.teal @@ -1,7 +1,7 @@ -#pragma version 9 +#pragma version 10 -// This TEAL was generated by TEALScript v0.51.1 -// https://github.com/algorand-devrel/TEALScript +// This TEAL was generated by TEALScript v0.96.0 +// https://github.com/algorandfoundation/TEALScript // This contract is compliant with and/or implements the following ARCs: [ ARC4 ] @@ -9,31 +9,21 @@ // This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed // Here, action refers to the OnComplete in combination with whether the app is being created or called // Every possible action for this contract is represented in the switch statement -// If the action is not implmented in the contract, its repsective branch will be "NOT_IMPLMENTED" which just contains "err" +// If the action is not implemented in the contract, its respective branch will be "*NOT_IMPLEMENTED" which just contains "err" txn ApplicationID -int 0 -> +! int 6 * txn OnCompletion + -switch create_NoOp NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED call_NoOp NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED call_UpdateApplication +switch *call_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *call_UpdateApplication *NOT_IMPLEMENTED *create_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED -NOT_IMPLEMENTED: +*NOT_IMPLEMENTED: + // The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID? err -// startUpload(pay,uint64,uint64,address)void -// -// -// Allocate boxes to begin data upload process -// -// @param pubKey The pubkey of the DID -// @param numBoxes The number of boxes that the data will take up -// @param endBoxSize The size of the last box -// @param mbrPayment Payment from the uploader to cover the box MBR -abi_route_startUpload: - byte 0x; dupn 3 // push empty bytes to fill the stack frame for this subroutine's local variables - +// startUpload(address,uint64,uint64,pay)void +*abi_route_startUpload: // mbrPayment: pay txn GroupIndex int 1 @@ -42,6 +32,8 @@ abi_route_startUpload: gtxns TypeEnum int pay == + + // argument 0 (mbrPayment) for startUpload must be a pay transaction assert // endBoxSize: uint64 @@ -58,97 +50,100 @@ abi_route_startUpload: len int 32 == + + // argument 3 (pubKey) for startUpload must be a address assert - // execute startUpload(pay,uint64,uint64,address)void + // execute startUpload(address,uint64,uint64,pay)void callsub startUpload int 1 return +// startUpload(pubKey: Address, numBoxes: uint64, endBoxSize: uint64, mbrPayment: PayTxn): void +// +// +// Allocate boxes to begin data upload process +// +// @param pubKey The pubkey of the DID +// @param numBoxes The number of boxes that the data will take up +// @param endBoxSize The size of the last box +// @param mbrPayment Payment from the uploader to cover the box MBR startUpload: - proto 8 0 + proto 4 0 - // contracts/algo-did.algo.ts:64 + // Push empty bytes after the frame pointer to reserve space for local variables + byte 0x + dupn 3 + + // contracts/algo-did.algo.ts:63 // assert(this.txn.sender === globals.creatorAddress) txn Sender global CreatorAddress == assert - // contracts/algo-did.algo.ts:66 + // contracts/algo-did.algo.ts:65 // startBox = this.currentIndex.value byte 0x63757272656e74496e646578 // "currentIndex" app_global_get - frame_bury -5 // startBox: uint64 + frame_bury 0 // startBox: uint64 - // contracts/algo-did.algo.ts:67 + // contracts/algo-did.algo.ts:66 // endBox = startBox + numBoxes - 1 - frame_dig -5 // startBox: uint64 + frame_dig 0 // startBox: uint64 frame_dig -2 // numBoxes: uint64 + int 1 - - frame_bury -6 // endBox: uint64 + frame_bury 1 // endBox: uint64 - // contracts/algo-did.algo.ts:69 + // contracts/algo-did.algo.ts:68 // metadata: Metadata = { - // start: startBox, - // end: endBox, - // status: UPLOADING, - // endSize: endBoxSize, - // lastDeleted: 0, + // start: startBox, end: endBox, status: UPLOADING, endSize: endBoxSize, lastDeleted: 0, // } - frame_dig -5 // startBox: uint64 + frame_dig 0 // startBox: uint64 itob - frame_dig -6 // endBox: uint64 + frame_dig 1 // endBox: uint64 itob concat byte 0x00 - byte 0x00 - bitlen - int 8 - <= - assert - byte 0xFF - b& concat frame_dig -3 // endBoxSize: uint64 itob concat byte 0x0000000000000000 concat - frame_bury -7 // metadata: Metadata + frame_bury 2 // metadata: Metadata - // contracts/algo-did.algo.ts:77 + // contracts/algo-did.algo.ts:72 // assert(!this.metadata(pubKey).exists) - frame_dig -1 // pubKey: address + frame_dig -1 // pubKey: Address box_len swap pop ! assert - // contracts/algo-did.algo.ts:79 + // contracts/algo-did.algo.ts:74 // this.metadata(pubKey).value = metadata - frame_dig -1 // pubKey: address - frame_dig -7 // metadata: Metadata + frame_dig -1 // pubKey: Address + frame_dig 2 // metadata: Metadata box_put - // contracts/algo-did.algo.ts:81 + // contracts/algo-did.algo.ts:76 // this.currentIndex.value = endBox + 1 byte 0x63757272656e74496e646578 // "currentIndex" - frame_dig -6 // endBox: uint64 + frame_dig 1 // endBox: uint64 int 1 + app_global_put - // contracts/algo-did.algo.ts:83 - // totalCost = numBoxes * COST_PER_BOX + // cost of data boxes - // (numBoxes - 1) * MAX_BOX_SIZE * COST_PER_BYTE + // cost of data - // numBoxes * 8 * COST_PER_BYTE + // cost of data keys - // endBoxSize * COST_PER_BYTE + // cost of last data box - // COST_PER_BOX + - // (8 + 8 + 1 + 8 + 32 + 8) * COST_PER_BYTE + // contracts/algo-did.algo.ts:78 + // totalCost = numBoxes * COST_PER_BOX // cost of data boxes + // + (numBoxes - 1) * MAX_BOX_SIZE * COST_PER_BYTE // cost of data + // + numBoxes * 8 * COST_PER_BYTE // cost of data keys + // + endBoxSize * COST_PER_BYTE // cost of last data box + // + COST_PER_BOX + (8 + 8 + 1 + 8 + 32 + 8) * COST_PER_BYTE frame_dig -2 // numBoxes: uint64 int 2500 * @@ -174,37 +169,27 @@ startUpload: + int 26000 + - frame_bury -8 // totalCost: uint64 + frame_bury 3 // totalCost: uint64 - // contracts/algo-did.algo.ts:90 + // contracts/algo-did.algo.ts:84 // assert(mbrPayment.amount === totalCost) - frame_dig -4 // mbrPayment: pay + frame_dig -4 // mbrPayment: PayTxn gtxns Amount - frame_dig -8 // totalCost: uint64 + frame_dig 3 // totalCost: uint64 == assert - // contracts/algo-did.algo.ts:91 + // contracts/algo-did.algo.ts:85 // assert(mbrPayment.receiver === this.app.address) - frame_dig -4 // mbrPayment: pay + frame_dig -4 // mbrPayment: PayTxn gtxns Receiver global CurrentApplicationAddress == assert retsub -// upload(bytes,uint64,uint64,address)void -// -// -// Upload data to a specific offset in a box -// -// @param pubKey The pubkey of the DID -// @param boxIndex The index of the box to upload the given chunk of data to -// @param offset The offset within the box to start writing the data -// @param data The data to write -abi_route_upload: - byte 0x // push empty bytes to fill the stack frame for this subroutine's local variables - +// upload(address,uint64,uint64,byte[])void +*abi_route_upload: // data: byte[] txna ApplicationArgs 4 extract 2 0 @@ -223,99 +208,113 @@ abi_route_upload: len int 32 == + + // argument 3 (pubKey) for upload must be a address assert - // execute upload(bytes,uint64,uint64,address)void + // execute upload(address,uint64,uint64,byte[])void callsub upload int 1 return +// upload(pubKey: Address, boxIndex: uint64, offset: uint64, data: bytes): void +// +// +// Upload data to a specific offset in a box +// +// @param pubKey The pubkey of the DID +// @param boxIndex The index of the box to upload the given chunk of data to +// @param offset The offset within the box to start writing the data +// @param data The data to write upload: - proto 5 0 + proto 4 0 - // contracts/algo-did.algo.ts:104 + // Push empty bytes after the frame pointer to reserve space for local variables + byte 0x + + // contracts/algo-did.algo.ts:98 // assert(this.txn.sender === globals.creatorAddress) txn Sender global CreatorAddress == assert - // contracts/algo-did.algo.ts:106 + // contracts/algo-did.algo.ts:100 // metadata = this.metadata(pubKey).value - frame_dig -1 // pubKey: address - frame_bury -5 // storage key//metadata + frame_dig -1 // pubKey: Address + frame_bury 0 // storage key//metadata - // contracts/algo-did.algo.ts:107 + // contracts/algo-did.algo.ts:101 // assert(metadata.status === UPLOADING) - frame_dig -5 // storage key//metadata - box_get - assert - extract 16 1 - byte 0x0000000000000000 - b== + frame_dig -1 // pubKey: Address + int 16 // headOffset + int 1 + box_extract + btoi + int 0 + == assert - // contracts/algo-did.algo.ts:108 + // contracts/algo-did.algo.ts:102 // assert(metadata.start <= boxIndex && boxIndex <= metadata.end) - frame_dig -5 // storage key//metadata - box_get - assert - extract 0 8 + frame_dig -1 // pubKey: Address + int 0 + int 8 + box_extract btoi frame_dig -2 // boxIndex: uint64 <= dup - bz skip_and0 + bz *skip_and0 frame_dig -2 // boxIndex: uint64 - frame_dig -5 // storage key//metadata - box_get - assert - extract 8 8 + frame_dig -1 // pubKey: Address + int 8 // headOffset + int 8 + box_extract btoi <= && -skip_and0: +*skip_and0: assert - // if0_condition - // contracts/algo-did.algo.ts:110 + // *if0_condition + // contracts/algo-did.algo.ts:104 // offset === 0 frame_dig -3 // offset: uint64 int 0 == - bz if0_end + bz *if0_end - // if0_consequent - // contracts/algo-did.algo.ts:111 - // this.dataBoxes(boxIndex).create( - // boxIndex === metadata.end ? metadata.endSize : MAX_BOX_SIZE, - // ) + // *if0_consequent + // contracts/algo-did.algo.ts:105 + // this.dataBoxes(boxIndex).create(boxIndex === metadata.end ? metadata.endSize : MAX_BOX_SIZE) frame_dig -2 // boxIndex: uint64 itob frame_dig -2 // boxIndex: uint64 - frame_dig -5 // storage key//metadata - box_get - assert - extract 8 8 + frame_dig -1 // pubKey: Address + int 8 // headOffset + int 8 + box_extract btoi == - bz ternary0_false - frame_dig -5 // storage key//metadata - box_get - assert - extract 17 8 + bz *ternary0_false + frame_dig -1 // pubKey: Address + int 17 // headOffset + int 8 + box_extract btoi - b ternary0_end + b *ternary0_end -ternary0_false: +*ternary0_false: int 32768 -ternary0_end: +*ternary0_end: box_create + pop -if0_end: - // contracts/algo-did.algo.ts:116 +*if0_end: + // contracts/algo-did.algo.ts:108 // this.dataBoxes(boxIndex).replace(offset, data) frame_dig -2 // boxIndex: uint64 itob @@ -325,18 +324,15 @@ if0_end: retsub // finishUpload(address)void -// -// -// Mark uploading as false -// -// @param pubKey The address of the DID -abi_route_finishUpload: +*abi_route_finishUpload: // pubKey: address txna ApplicationArgs 1 dup len int 32 == + + // argument 0 (pubKey) for finishUpload must be a address assert // execute finishUpload(address)void @@ -344,38 +340,40 @@ abi_route_finishUpload: int 1 return +// finishUpload(pubKey: Address): void +// +// +// Mark uploading as false +// +// @param pubKey The address of the DID finishUpload: proto 1 0 - // contracts/algo-did.algo.ts:126 + // contracts/algo-did.algo.ts:118 // assert(this.txn.sender === globals.creatorAddress) txn Sender global CreatorAddress == assert - // contracts/algo-did.algo.ts:128 + // contracts/algo-did.algo.ts:120 // this.metadata(pubKey).value.status = READY - frame_dig -1 // pubKey: address - int 16 + frame_dig -1 // pubKey: Address + int 16 // headOffset byte 0x01 box_replace retsub // startDelete(address)void -// -// Starts the deletion process for the data associated with a DID -// -// @param pubKey The address of the DID -abi_route_startDelete: - byte 0x // push empty bytes to fill the stack frame for this subroutine's local variables - +*abi_route_startDelete: // pubKey: address txna ApplicationArgs 1 dup len int 32 == + + // argument 0 (pubKey) for startDelete must be a address assert // execute startDelete(address)void @@ -383,52 +381,50 @@ abi_route_startDelete: int 1 return +// startDelete(pubKey: Address): void +// +// Starts the deletion process for the data associated with a DID +// +// @param pubKey The address of the DID startDelete: - proto 2 0 + proto 1 0 + + // Push empty bytes after the frame pointer to reserve space for local variables + byte 0x - // contracts/algo-did.algo.ts:137 + // contracts/algo-did.algo.ts:129 // assert(this.txn.sender === globals.creatorAddress) txn Sender global CreatorAddress == assert - // contracts/algo-did.algo.ts:139 + // contracts/algo-did.algo.ts:131 // metadata = this.metadata(pubKey).value - frame_dig -1 // pubKey: address - frame_bury -2 // storage key//metadata + frame_dig -1 // pubKey: Address + frame_bury 0 // storage key//metadata - // contracts/algo-did.algo.ts:140 + // contracts/algo-did.algo.ts:132 // assert(metadata.status === READY) - frame_dig -2 // storage key//metadata - box_get - assert - extract 16 1 - byte 0x0000000000000001 - b== + frame_dig -1 // pubKey: Address + int 16 // headOffset + int 1 + box_extract + btoi + int 1 + == assert - // contracts/algo-did.algo.ts:142 + // contracts/algo-did.algo.ts:134 // metadata.status = DELETING - frame_dig -2 // storage key//metadata - box_get - assert + frame_dig 0 // storage key//metadata + int 16 // headOffset byte 0x02 - replace2 16 - frame_dig -2 // storage key//metadata - swap - box_put + box_replace retsub -// deleteData(uint64,address)void -// -// Deletes a box of data -// -// @param pubKey The address of the DID -// @param boxIndex The index of the box to delete -abi_route_deleteData: - byte 0x; dup // push empty bytes to fill the stack frame for this subroutine's local variables - +// deleteData(address,uint64)void +*abi_route_deleteData: // boxIndex: uint64 txna ApplicationArgs 2 btoi @@ -439,80 +435,93 @@ abi_route_deleteData: len int 32 == + + // argument 1 (pubKey) for deleteData must be a address assert - // execute deleteData(uint64,address)void + // execute deleteData(address,uint64)void callsub deleteData int 1 return +// deleteData(pubKey: Address, boxIndex: uint64): void +// +// Deletes a box of data +// +// @param pubKey The address of the DID +// @param boxIndex The index of the box to delete deleteData: - proto 4 0 + proto 2 0 - // contracts/algo-did.algo.ts:152 + // Push empty bytes after the frame pointer to reserve space for local variables + byte 0x + dup + + // contracts/algo-did.algo.ts:144 // assert(this.txn.sender === globals.creatorAddress) txn Sender global CreatorAddress == assert - // contracts/algo-did.algo.ts:154 + // contracts/algo-did.algo.ts:146 // metadata = this.metadata(pubKey).value - frame_dig -1 // pubKey: address - frame_bury -3 // storage key//metadata + frame_dig -1 // pubKey: Address + frame_bury 0 // storage key//metadata - // contracts/algo-did.algo.ts:155 + // contracts/algo-did.algo.ts:147 // assert(metadata.status === DELETING) - frame_dig -3 // storage key//metadata - box_get - assert - extract 16 1 - byte 0x0000000000000002 - b== + frame_dig -1 // pubKey: Address + int 16 // headOffset + int 1 + box_extract + btoi + int 2 + == assert - // contracts/algo-did.algo.ts:156 + // contracts/algo-did.algo.ts:148 // assert(metadata.start <= boxIndex && boxIndex <= metadata.end) - frame_dig -3 // storage key//metadata - box_get - assert - extract 0 8 + frame_dig -1 // pubKey: Address + int 0 + int 8 + box_extract btoi frame_dig -2 // boxIndex: uint64 <= dup - bz skip_and1 + bz *skip_and1 frame_dig -2 // boxIndex: uint64 - frame_dig -3 // storage key//metadata - box_get - assert - extract 8 8 + frame_dig -1 // pubKey: Address + int 8 // headOffset + int 8 + box_extract btoi <= && -skip_and1: +*skip_and1: assert - // if1_condition - // contracts/algo-did.algo.ts:158 + // *if1_condition + // contracts/algo-did.algo.ts:150 // boxIndex !== metadata.start frame_dig -2 // boxIndex: uint64 - frame_dig -3 // storage key//metadata - box_get - assert - extract 0 8 + frame_dig -1 // pubKey: Address + int 0 + int 8 + box_extract btoi != - bz if1_end + bz *if1_end - // if1_consequent - // contracts/algo-did.algo.ts:159 + // *if1_consequent + // contracts/algo-did.algo.ts:150 // assert(metadata.lastDeleted === boxIndex - 1) - frame_dig -3 // storage key//metadata - box_get - assert - extract 25 8 + frame_dig -1 // pubKey: Address + int 25 // headOffset + int 8 + box_extract btoi frame_dig -2 // boxIndex: uint64 int 1 @@ -520,54 +529,51 @@ skip_and1: == assert -if1_end: - // contracts/algo-did.algo.ts:162 +*if1_end: + // contracts/algo-did.algo.ts:152 // preMBR = globals.currentApplicationAddress.minBalance global CurrentApplicationAddress acct_params_get AcctMinBalance - assert - frame_bury -4 // preMBR: uint64 + pop + frame_bury 1 // preMBR: uint64 - // contracts/algo-did.algo.ts:164 + // contracts/algo-did.algo.ts:154 // this.dataBoxes(boxIndex).delete() frame_dig -2 // boxIndex: uint64 itob box_del - // if2_condition - // contracts/algo-did.algo.ts:166 + // *if2_condition + // contracts/algo-did.algo.ts:156 // boxIndex === metadata.end frame_dig -2 // boxIndex: uint64 - frame_dig -3 // storage key//metadata - box_get - assert - extract 8 8 + frame_dig -1 // pubKey: Address + int 8 // headOffset + int 8 + box_extract btoi == - bz if2_else + bz *if2_else - // if2_consequent - // contracts/algo-did.algo.ts:166 + // *if2_consequent + // contracts/algo-did.algo.ts:156 // this.metadata(pubKey).delete() - frame_dig -1 // pubKey: address + frame_dig -1 // pubKey: Address box_del - b if2_end + b *if2_end -if2_else: - // contracts/algo-did.algo.ts:167 +*if2_else: + // contracts/algo-did.algo.ts:157 // metadata.lastDeleted = boxIndex - frame_dig -3 // storage key//metadata - box_get - assert + int 25 // headOffset frame_dig -2 // boxIndex: uint64 itob - replace2 25 - frame_dig -3 // storage key//metadata - swap - box_put + frame_dig 0 // storage key//metadata + cover 2 + box_replace -if2_end: - // contracts/algo-did.algo.ts:169 +*if2_end: + // contracts/algo-did.algo.ts:159 // sendPayment({ // amount: preMBR - globals.currentApplicationAddress.minBalance, // receiver: this.txn.sender, @@ -576,16 +582,16 @@ if2_end: int pay itxn_field TypeEnum - // contracts/algo-did.algo.ts:170 + // contracts/algo-did.algo.ts:160 // amount: preMBR - globals.currentApplicationAddress.minBalance - frame_dig -4 // preMBR: uint64 + frame_dig 1 // preMBR: uint64 global CurrentApplicationAddress acct_params_get AcctMinBalance - assert + pop - itxn_field Amount - // contracts/algo-did.algo.ts:171 + // contracts/algo-did.algo.ts:161 // receiver: this.txn.sender txn Sender itxn_field Receiver @@ -599,18 +605,19 @@ if2_end: retsub // updateApplication()void -// -// Allow the contract to be updated by the creator -abi_route_updateApplication: +*abi_route_updateApplication: // execute updateApplication()void callsub updateApplication int 1 return +// updateApplication(): void +// +// Allow the contract to be updated by the creator updateApplication: proto 0 0 - // contracts/algo-did.algo.ts:179 + // contracts/algo-did.algo.ts:169 // assert(this.txn.sender === globals.creatorAddress) txn Sender global CreatorAddress @@ -619,32 +626,35 @@ updateApplication: retsub // dummy()void -// -// Dummy function to add extra box references for deleteData. -// Boxes are 32k, but a single app call can only include enough references to read/write 8k -// at a time. Thus when a box is deleted, we need to add additional dummy calls with box -// references to increase the total read/write budget to 32k. -abi_route_dummy: +*abi_route_dummy: // execute dummy()void callsub dummy int 1 return +// dummy(): void +// +// Dummy function to add extra box references for deleteData. +// Boxes are 32k, but a single app call can only inlcude enough references to read/write 8k +// at a time. Thus when a box is deleted, we need to add additional dummy calls with box +// references to increase the total read/write budget to 32k. dummy: proto 0 0 retsub -abi_route_createApplication: +*abi_route_createApplication: int 1 return -create_NoOp: +*create_NoOp: method "createApplication()void" txna ApplicationArgs 0 - match abi_route_createApplication + match *abi_route_createApplication + + // this contract does not implement the given ABI method for create NoOp err -call_NoOp: +*call_NoOp: method "startUpload(address,uint64,uint64,pay)void" method "upload(address,uint64,uint64,byte[])void" method "finishUpload(address)void" @@ -652,11 +662,15 @@ call_NoOp: method "deleteData(address,uint64)void" method "dummy()void" txna ApplicationArgs 0 - match abi_route_startUpload abi_route_upload abi_route_finishUpload abi_route_startDelete abi_route_deleteData abi_route_dummy + match *abi_route_startUpload *abi_route_upload *abi_route_finishUpload *abi_route_startDelete *abi_route_deleteData *abi_route_dummy + + // this contract does not implement the given ABI method for call NoOp err -call_UpdateApplication: +*call_UpdateApplication: method "updateApplication()void" txna ApplicationArgs 0 - match abi_route_updateApplication + match *abi_route_updateApplication + + // this contract does not implement the given ABI method for call UpdateApplication err \ No newline at end of file diff --git a/client/internal/contracts/AlgoDID.arc32.json b/client/internal/contracts/AlgoDID.arc32.json new file mode 100644 index 0000000..9d43dc9 --- /dev/null +++ b/client/internal/contracts/AlgoDID.arc32.json @@ -0,0 +1,214 @@ +{ + "hints": { + "startUpload(address,uint64,uint64,pay)void": { + "call_config": { + "no_op": "CALL" + } + }, + "upload(address,uint64,uint64,byte[])void": { + "call_config": { + "no_op": "CALL" + } + }, + "finishUpload(address)void": { + "call_config": { + "no_op": "CALL" + } + }, + "startDelete(address)void": { + "call_config": { + "no_op": "CALL" + } + }, + "deleteData(address,uint64)void": { + "call_config": { + "no_op": "CALL" + } + }, + "updateApplication()void": { + "call_config": { + "update_application": "CALL" + } + }, + "dummy()void": { + "call_config": { + "no_op": "CALL" + } + }, + "createApplication()void": { + "call_config": { + "no_op": "CREATE" + } + } + }, + "bare_call_config": { + "no_op": "NEVER", + "opt_in": "NEVER", + "close_out": "NEVER", + "update_application": "NEVER", + "delete_application": "NEVER" + }, + "schema": { + "local": { + "declared": {}, + "reserved": {} + }, + "global": { + "declared": { + "currentIndex": { + "type": "uint64", + "key": "currentIndex" + } + }, + "reserved": {} + } + }, + "state": { + "global": { + "num_byte_slices": 0, + "num_uints": 1 + }, + "local": { + "num_byte_slices": 0, + "num_uints": 0 + } + }, + "source": { + "approval": "#pragma version 10

// This TEAL was generated by TEALScript v0.96.0
// https://github.com/algorandfoundation/TEALScript

// This contract is compliant with and/or implements the following ARCs: [ ARC4 ]

// The following ten lines of TEAL handle initial program flow
// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed
// Here, action refers to the OnComplete in combination with whether the app is being created or called
// Every possible action for this contract is represented in the switch statement
// If the action is not implemented in the contract, its respective branch will be "*NOT_IMPLEMENTED" which just contains "err"
txn ApplicationID
!
int 6
*
txn OnCompletion
+
switch *call_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *call_UpdateApplication *NOT_IMPLEMENTED *create_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED

*NOT_IMPLEMENTED:
	// The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?
	err

// startUpload(address,uint64,uint64,pay)void
*abi_route_startUpload:
	// mbrPayment: pay
	txn GroupIndex
	int 1
	-
	dup
	gtxns TypeEnum
	int pay
	==

	// argument 0 (mbrPayment) for startUpload must be a pay transaction
	assert

	// endBoxSize: uint64
	txna ApplicationArgs 3
	btoi

	// numBoxes: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 3 (pubKey) for startUpload must be a address
	assert

	// execute startUpload(address,uint64,uint64,pay)void
	callsub startUpload
	int 1
	return

// startUpload(pubKey: Address, numBoxes: uint64, endBoxSize: uint64, mbrPayment: PayTxn): void
//
//
// Allocate boxes to begin data upload process
//
// @param pubKey The pubkey of the DID
// @param numBoxes The number of boxes that the data will take up
// @param endBoxSize The size of the last box
// @param mbrPayment Payment from the uploader to cover the box MBR
startUpload:
	proto 4 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x
	dupn 3

	// contracts/algo-did.algo.ts:63
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:65
	// startBox = this.currentIndex.value
	byte 0x63757272656e74496e646578 // "currentIndex"
	app_global_get
	frame_bury 0 // startBox: uint64

	// contracts/algo-did.algo.ts:66
	// endBox = startBox + numBoxes - 1
	frame_dig 0 // startBox: uint64
	frame_dig -2 // numBoxes: uint64
	+
	int 1
	-
	frame_bury 1 // endBox: uint64

	// contracts/algo-did.algo.ts:68
	// metadata: Metadata = {
	//       start: startBox, end: endBox, status: UPLOADING, endSize: endBoxSize, lastDeleted: 0,
	//     }
	frame_dig 0 // startBox: uint64
	itob
	frame_dig 1 // endBox: uint64
	itob
	concat
	byte 0x00
	concat
	frame_dig -3 // endBoxSize: uint64
	itob
	concat
	byte 0x0000000000000000
	concat
	frame_bury 2 // metadata: Metadata

	// contracts/algo-did.algo.ts:72
	// assert(!this.metadata(pubKey).exists)
	frame_dig -1 // pubKey: Address
	box_len
	swap
	pop
	!
	assert

	// contracts/algo-did.algo.ts:74
	// this.metadata(pubKey).value = metadata
	frame_dig -1 // pubKey: Address
	frame_dig 2 // metadata: Metadata
	box_put

	// contracts/algo-did.algo.ts:76
	// this.currentIndex.value = endBox + 1
	byte 0x63757272656e74496e646578 // "currentIndex"
	frame_dig 1 // endBox: uint64
	int 1
	+
	app_global_put

	// contracts/algo-did.algo.ts:78
	// totalCost = numBoxes * COST_PER_BOX // cost of data boxes
	//     + (numBoxes - 1) * MAX_BOX_SIZE * COST_PER_BYTE // cost of data
	//     + numBoxes * 8 * COST_PER_BYTE // cost of data keys
	//     + endBoxSize * COST_PER_BYTE // cost of last data box
	//     + COST_PER_BOX + (8 + 8 + 1 + 8 + 32 + 8) * COST_PER_BYTE
	frame_dig -2 // numBoxes: uint64
	int 2500
	*
	frame_dig -2 // numBoxes: uint64
	int 1
	-
	int 32768
	*
	int 400
	*
	+
	frame_dig -2 // numBoxes: uint64
	int 8
	*
	int 400
	*
	+
	frame_dig -3 // endBoxSize: uint64
	int 400
	*
	+
	int 2500
	+
	int 26000
	+
	frame_bury 3 // totalCost: uint64

	// contracts/algo-did.algo.ts:84
	// assert(mbrPayment.amount === totalCost)
	frame_dig -4 // mbrPayment: PayTxn
	gtxns Amount
	frame_dig 3 // totalCost: uint64
	==
	assert

	// contracts/algo-did.algo.ts:85
	// assert(mbrPayment.receiver === this.app.address)
	frame_dig -4 // mbrPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==
	assert
	retsub

// upload(address,uint64,uint64,byte[])void
*abi_route_upload:
	// data: byte[]
	txna ApplicationArgs 4
	extract 2 0

	// offset: uint64
	txna ApplicationArgs 3
	btoi

	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 3 (pubKey) for upload must be a address
	assert

	// execute upload(address,uint64,uint64,byte[])void
	callsub upload
	int 1
	return

// upload(pubKey: Address, boxIndex: uint64, offset: uint64, data: bytes): void
//
//
// Upload data to a specific offset in a box
//
// @param pubKey The pubkey of the DID
// @param boxIndex The index of the box to upload the given chunk of data to
// @param offset The offset within the box to start writing the data
// @param data The data to write
upload:
	proto 4 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x

	// contracts/algo-did.algo.ts:98
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:100
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: Address
	frame_bury 0 // storage key//metadata

	// contracts/algo-did.algo.ts:101
	// assert(metadata.status === UPLOADING)
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	int 1
	box_extract
	btoi
	int 0
	==
	assert

	// contracts/algo-did.algo.ts:102
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -1 // pubKey: Address
	int 0
	int 8
	box_extract
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz *skip_and0
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	<=
	&&

*skip_and0:
	assert

	// *if0_condition
	// contracts/algo-did.algo.ts:104
	// offset === 0
	frame_dig -3 // offset: uint64
	int 0
	==
	bz *if0_end

	// *if0_consequent
	// contracts/algo-did.algo.ts:105
	// this.dataBoxes(boxIndex).create(boxIndex === metadata.end ? metadata.endSize : MAX_BOX_SIZE)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	==
	bz *ternary0_false
	frame_dig -1 // pubKey: Address
	int 17 // headOffset
	int 8
	box_extract
	btoi
	b *ternary0_end

*ternary0_false:
	int 32768

*ternary0_end:
	box_create
	pop

*if0_end:
	// contracts/algo-did.algo.ts:108
	// this.dataBoxes(boxIndex).replace(offset, data)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -3 // offset: uint64
	frame_dig -4 // data: bytes
	box_replace
	retsub

// finishUpload(address)void
*abi_route_finishUpload:
	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 0 (pubKey) for finishUpload must be a address
	assert

	// execute finishUpload(address)void
	callsub finishUpload
	int 1
	return

// finishUpload(pubKey: Address): void
//
//
// Mark uploading as false
//
// @param pubKey The address of the DID
finishUpload:
	proto 1 0

	// contracts/algo-did.algo.ts:118
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:120
	// this.metadata(pubKey).value.status = READY
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	byte 0x01
	box_replace
	retsub

// startDelete(address)void
*abi_route_startDelete:
	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 0 (pubKey) for startDelete must be a address
	assert

	// execute startDelete(address)void
	callsub startDelete
	int 1
	return

// startDelete(pubKey: Address): void
//
// Starts the deletion process for the data associated with a DID
//
// @param pubKey The address of the DID
startDelete:
	proto 1 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x

	// contracts/algo-did.algo.ts:129
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:131
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: Address
	frame_bury 0 // storage key//metadata

	// contracts/algo-did.algo.ts:132
	// assert(metadata.status === READY)
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	int 1
	box_extract
	btoi
	int 1
	==
	assert

	// contracts/algo-did.algo.ts:134
	// metadata.status = DELETING
	frame_dig 0 // storage key//metadata
	int 16 // headOffset
	byte 0x02
	box_replace
	retsub

// deleteData(address,uint64)void
*abi_route_deleteData:
	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 1 (pubKey) for deleteData must be a address
	assert

	// execute deleteData(address,uint64)void
	callsub deleteData
	int 1
	return

// deleteData(pubKey: Address, boxIndex: uint64): void
//
// Deletes a box of data
//
// @param pubKey The address of the DID
// @param boxIndex The index of the box to delete
deleteData:
	proto 2 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x
	dup

	// contracts/algo-did.algo.ts:144
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:146
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: Address
	frame_bury 0 // storage key//metadata

	// contracts/algo-did.algo.ts:147
	// assert(metadata.status === DELETING)
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	int 1
	box_extract
	btoi
	int 2
	==
	assert

	// contracts/algo-did.algo.ts:148
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -1 // pubKey: Address
	int 0
	int 8
	box_extract
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz *skip_and1
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	<=
	&&

*skip_and1:
	assert

	// *if1_condition
	// contracts/algo-did.algo.ts:150
	// boxIndex !== metadata.start
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 0
	int 8
	box_extract
	btoi
	!=
	bz *if1_end

	// *if1_consequent
	// contracts/algo-did.algo.ts:150
	// assert(metadata.lastDeleted === boxIndex - 1)
	frame_dig -1 // pubKey: Address
	int 25 // headOffset
	int 8
	box_extract
	btoi
	frame_dig -2 // boxIndex: uint64
	int 1
	-
	==
	assert

*if1_end:
	// contracts/algo-did.algo.ts:152
	// preMBR = globals.currentApplicationAddress.minBalance
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	pop
	frame_bury 1 // preMBR: uint64

	// contracts/algo-did.algo.ts:154
	// this.dataBoxes(boxIndex).delete()
	frame_dig -2 // boxIndex: uint64
	itob
	box_del

	// *if2_condition
	// contracts/algo-did.algo.ts:156
	// boxIndex === metadata.end
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	==
	bz *if2_else

	// *if2_consequent
	// contracts/algo-did.algo.ts:156
	// this.metadata(pubKey).delete()
	frame_dig -1 // pubKey: Address
	box_del
	b *if2_end

*if2_else:
	// contracts/algo-did.algo.ts:157
	// metadata.lastDeleted = boxIndex
	int 25 // headOffset
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig 0 // storage key//metadata
	cover 2
	box_replace

*if2_end:
	// contracts/algo-did.algo.ts:159
	// sendPayment({
	//       amount: preMBR - globals.currentApplicationAddress.minBalance,
	//       receiver: this.txn.sender,
	//     })
	itxn_begin
	int pay
	itxn_field TypeEnum

	// contracts/algo-did.algo.ts:160
	// amount: preMBR - globals.currentApplicationAddress.minBalance
	frame_dig 1 // preMBR: uint64
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	pop
	-
	itxn_field Amount

	// contracts/algo-did.algo.ts:161
	// receiver: this.txn.sender
	txn Sender
	itxn_field Receiver

	// Fee field not set, defaulting to 0
	int 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// updateApplication()void
*abi_route_updateApplication:
	// execute updateApplication()void
	callsub updateApplication
	int 1
	return

// updateApplication(): void
//
// Allow the contract to be updated by the creator
updateApplication:
	proto 0 0

	// contracts/algo-did.algo.ts:169
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert
	retsub

// dummy()void
*abi_route_dummy:
	// execute dummy()void
	callsub dummy
	int 1
	return

// dummy(): void
//
// Dummy function to add extra box references for deleteData.
// Boxes are 32k, but a single app call can only inlcude enough references to read/write 8k
// at a time. Thus when a box is deleted, we need to add additional dummy calls with box
// references to increase the total read/write budget to 32k.
dummy:
	proto 0 0
	retsub

*abi_route_createApplication:
	int 1
	return

*create_NoOp:
	method "createApplication()void"
	txna ApplicationArgs 0
	match *abi_route_createApplication

	// this contract does not implement the given ABI method for create NoOp
	err

*call_NoOp:
	method "startUpload(address,uint64,uint64,pay)void"
	method "upload(address,uint64,uint64,byte[])void"
	method "finishUpload(address)void"
	method "startDelete(address)void"
	method "deleteData(address,uint64)void"
	method "dummy()void"
	txna ApplicationArgs 0
	match *abi_route_startUpload *abi_route_upload *abi_route_finishUpload *abi_route_startDelete *abi_route_deleteData *abi_route_dummy

	// this contract does not implement the given ABI method for call NoOp
	err

*call_UpdateApplication:
	method "updateApplication()void"
	txna ApplicationArgs 0
	match *abi_route_updateApplication

	// this contract does not implement the given ABI method for call UpdateApplication
	err", + "clear": "I3ByYWdtYSB2ZXJzaW9uIDEw" + }, + "contract": { + "name": "AlgoDID", + "desc": "", + "methods": [ + { + "name": "startUpload", + "desc": "Allocate boxes to begin data upload process", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The pubkey of the DID" + }, + { + "name": "numBoxes", + "type": "uint64", + "desc": "The number of boxes that the data will take up" + }, + { + "name": "endBoxSize", + "type": "uint64", + "desc": "The size of the last box" + }, + { + "name": "mbrPayment", + "type": "pay", + "desc": "Payment from the uploader to cover the box MBR" + } + ], + "returns": { + "type": "void" + } + }, + { + "name": "upload", + "desc": "Upload data to a specific offset in a box", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The pubkey of the DID" + }, + { + "name": "boxIndex", + "type": "uint64", + "desc": "The index of the box to upload the given chunk of data to" + }, + { + "name": "offset", + "type": "uint64", + "desc": "The offset within the box to start writing the data" + }, + { + "name": "data", + "type": "byte[]", + "desc": "The data to write" + } + ], + "returns": { + "type": "void" + } + }, + { + "name": "finishUpload", + "desc": "Mark uploading as false", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + } + ], + "returns": { + "type": "void" + } + }, + { + "name": "startDelete", + "desc": "Starts the deletion process for the data associated with a DID", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + } + ], + "returns": { + "type": "void" + } + }, + { + "name": "deleteData", + "desc": "Deletes a box of data", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + }, + { + "name": "boxIndex", + "type": "uint64", + "desc": "The index of the box to delete" + } + ], + "returns": { + "type": "void" + } + }, + { + "name": "updateApplication", + "desc": "Allow the contract to be updated by the creator", + "args": [], + "returns": { + "type": "void" + } + }, + { + "name": "dummy", + "desc": "Dummy function to add extra box references for deleteData.Boxes are 32k, but a single app call can only inlcude enough references to read/write 8kat a time. Thus when a box is deleted, we need to add additional dummy calls with boxreferences to increase the total read/write budget to 32k.", + "args": [], + "returns": { + "type": "void" + } + }, + { + "name": "createApplication", + "args": [], + "returns": { + "type": "void" + } + } + ] + } +} \ No newline at end of file diff --git a/client/internal/contracts/AlgoDID.arc4.json b/client/internal/contracts/AlgoDID.arc4.json new file mode 100644 index 0000000..59184cc --- /dev/null +++ b/client/internal/contracts/AlgoDID.arc4.json @@ -0,0 +1,134 @@ +{ + "name": "AlgoDID", + "desc": "", + "methods": [ + { + "name": "startUpload", + "desc": "Allocate boxes to begin data upload process", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The pubkey of the DID" + }, + { + "name": "numBoxes", + "type": "uint64", + "desc": "The number of boxes that the data will take up" + }, + { + "name": "endBoxSize", + "type": "uint64", + "desc": "The size of the last box" + }, + { + "name": "mbrPayment", + "type": "pay", + "desc": "Payment from the uploader to cover the box MBR" + } + ], + "returns": { + "type": "void" + } + }, + { + "name": "upload", + "desc": "Upload data to a specific offset in a box", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The pubkey of the DID" + }, + { + "name": "boxIndex", + "type": "uint64", + "desc": "The index of the box to upload the given chunk of data to" + }, + { + "name": "offset", + "type": "uint64", + "desc": "The offset within the box to start writing the data" + }, + { + "name": "data", + "type": "byte[]", + "desc": "The data to write" + } + ], + "returns": { + "type": "void" + } + }, + { + "name": "finishUpload", + "desc": "Mark uploading as false", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + } + ], + "returns": { + "type": "void" + } + }, + { + "name": "startDelete", + "desc": "Starts the deletion process for the data associated with a DID", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + } + ], + "returns": { + "type": "void" + } + }, + { + "name": "deleteData", + "desc": "Deletes a box of data", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + }, + { + "name": "boxIndex", + "type": "uint64", + "desc": "The index of the box to delete" + } + ], + "returns": { + "type": "void" + } + }, + { + "name": "updateApplication", + "desc": "Allow the contract to be updated by the creator", + "args": [], + "returns": { + "type": "void" + } + }, + { + "name": "dummy", + "desc": "Dummy function to add extra box references for deleteData.Boxes are 32k, but a single app call can only inlcude enough references to read/write 8kat a time. Thus when a box is deleted, we need to add additional dummy calls with boxreferences to increase the total read/write budget to 32k.", + "args": [], + "returns": { + "type": "void" + } + }, + { + "name": "createApplication", + "args": [], + "returns": { + "type": "void" + } + } + ] +} \ No newline at end of file diff --git a/client/internal/contracts/AlgoDID.arc56_draft.json b/client/internal/contracts/AlgoDID.arc56_draft.json new file mode 100644 index 0000000..497ad1a --- /dev/null +++ b/client/internal/contracts/AlgoDID.arc56_draft.json @@ -0,0 +1,3189 @@ +{ + "name": "AlgoDID", + "desc": "", + "methods": [ + { + "name": "startUpload", + "desc": "Allocate boxes to begin data upload process", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The pubkey of the DID" + }, + { + "name": "numBoxes", + "type": "uint64", + "desc": "The number of boxes that the data will take up" + }, + { + "name": "endBoxSize", + "type": "uint64", + "desc": "The size of the last box" + }, + { + "name": "mbrPayment", + "type": "pay", + "desc": "Payment from the uploader to cover the box MBR" + } + ], + "returns": { + "type": "void" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + } + }, + { + "name": "upload", + "desc": "Upload data to a specific offset in a box", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The pubkey of the DID" + }, + { + "name": "boxIndex", + "type": "uint64", + "desc": "The index of the box to upload the given chunk of data to" + }, + { + "name": "offset", + "type": "uint64", + "desc": "The offset within the box to start writing the data" + }, + { + "name": "data", + "type": "byte[]", + "desc": "The data to write" + } + ], + "returns": { + "type": "void" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + } + }, + { + "name": "finishUpload", + "desc": "Mark uploading as false", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + } + ], + "returns": { + "type": "void" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + } + }, + { + "name": "startDelete", + "desc": "Starts the deletion process for the data associated with a DID", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + } + ], + "returns": { + "type": "void" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + } + }, + { + "name": "deleteData", + "desc": "Deletes a box of data", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + }, + { + "name": "boxIndex", + "type": "uint64", + "desc": "The index of the box to delete" + } + ], + "returns": { + "type": "void" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + } + }, + { + "name": "updateApplication", + "desc": "Allow the contract to be updated by the creator", + "args": [], + "returns": { + "type": "void" + }, + "actions": { + "create": [], + "call": [ + "UpdateApplication" + ] + } + }, + { + "name": "dummy", + "desc": "Dummy function to add extra box references for deleteData.Boxes are 32k, but a single app call can only inlcude enough references to read/write 8kat a time. Thus when a box is deleted, we need to add additional dummy calls with boxreferences to increase the total read/write budget to 32k.", + "args": [], + "returns": { + "type": "void" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + } + }, + { + "name": "createApplication", + "args": [], + "returns": { + "type": "void" + }, + "actions": { + "create": [ + "NoOp" + ], + "call": [] + } + } + ], + "arcs": [ + 4, + 56 + ], + "structs": { + "Metadata": { + "start": "uint64", + "end": "uint64", + "status": "uint8", + "endSize": "uint64", + "lastDeleted": "uint64" + } + }, + "state": { + "schema": { + "global": { + "bytes": 0, + "ints": 1 + }, + "local": { + "bytes": 0, + "ints": 0 + } + }, + "keys": { + "global": { + "currentIndex": { + "key": "Y3VycmVudEluZGV4", + "keyType": "bytes", + "valueType": "uint64" + } + }, + "local": {}, + "box": {} + }, + "maps": { + "global": {}, + "local": {}, + "box": { + "dataBoxes": { + "keyType": "uint64", + "valueType": "bytes" + }, + "metadata": { + "keyType": "address", + "valueType": "Metadata" + } + } + } + }, + "bareActions": { + "create": [], + "call": [] + }, + "sourceInfo": [ + { + "teal": 1, + "source": 38, + "pc": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31 + ] + }, + { + "teal": 13, + "source": 38, + "pc": [ + 32, + 33 + ] + }, + { + "teal": 14, + "source": 38, + "pc": [ + 34 + ] + }, + { + "teal": 15, + "source": 38, + "pc": [ + 35, + 36 + ] + }, + { + "teal": 16, + "source": 38, + "pc": [ + 37 + ] + }, + { + "teal": 17, + "source": 38, + "pc": [ + 38, + 39 + ] + }, + { + "teal": 18, + "source": 38, + "pc": [ + 40 + ] + }, + { + "teal": 19, + "source": 38, + "pc": [ + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66 + ] + }, + { + "teal": 23, + "source": 38, + "errorMessage": "The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?", + "pc": [ + 67 + ] + }, + { + "teal": 28, + "source": 61, + "pc": [ + 68, + 69 + ] + }, + { + "teal": 29, + "source": 61, + "pc": [ + 70 + ] + }, + { + "teal": 30, + "source": 61, + "pc": [ + 71 + ] + }, + { + "teal": 31, + "source": 61, + "pc": [ + 72 + ] + }, + { + "teal": 32, + "source": 61, + "pc": [ + 73, + 74 + ] + }, + { + "teal": 33, + "source": 61, + "pc": [ + 75 + ] + }, + { + "teal": 34, + "source": 61, + "pc": [ + 76 + ] + }, + { + "teal": 37, + "source": 61, + "errorMessage": "argument 0 (mbrPayment) for startUpload must be a pay transaction", + "pc": [ + 77 + ] + }, + { + "teal": 40, + "source": 60, + "pc": [ + 78, + 79, + 80 + ] + }, + { + "teal": 41, + "source": 60, + "pc": [ + 81 + ] + }, + { + "teal": 44, + "source": 59, + "pc": [ + 82, + 83, + 84 + ] + }, + { + "teal": 45, + "source": 59, + "pc": [ + 85 + ] + }, + { + "teal": 48, + "source": 58, + "pc": [ + 86, + 87, + 88 + ] + }, + { + "teal": 49, + "source": 58, + "pc": [ + 89 + ] + }, + { + "teal": 50, + "source": 58, + "pc": [ + 90 + ] + }, + { + "teal": 51, + "source": 58, + "pc": [ + 91 + ] + }, + { + "teal": 52, + "source": 58, + "pc": [ + 92 + ] + }, + { + "teal": 55, + "source": 58, + "errorMessage": "argument 3 (pubKey) for startUpload must be a address", + "pc": [ + 93 + ] + }, + { + "teal": 58, + "source": 57, + "pc": [ + 94, + 95, + 96 + ] + }, + { + "teal": 59, + "source": 57, + "pc": [ + 97 + ] + }, + { + "teal": 60, + "source": 57, + "pc": [ + 98 + ] + }, + { + "teal": 72, + "source": 57, + "pc": [ + 99, + 100, + 101 + ] + }, + { + "teal": 75, + "source": 57, + "pc": [ + 102 + ] + }, + { + "teal": 76, + "source": 57, + "pc": [ + 103, + 104 + ] + }, + { + "teal": 80, + "source": 63, + "pc": [ + 105, + 106 + ] + }, + { + "teal": 81, + "source": 63, + "pc": [ + 107, + 108 + ] + }, + { + "teal": 82, + "source": 63, + "pc": [ + 109 + ] + }, + { + "teal": 83, + "source": 63, + "pc": [ + 110 + ] + }, + { + "teal": 87, + "source": 65, + "pc": [ + 111 + ] + }, + { + "teal": 88, + "source": 65, + "pc": [ + 112 + ] + }, + { + "teal": 89, + "source": 65, + "pc": [ + 113, + 114 + ] + }, + { + "teal": 93, + "source": 66, + "pc": [ + 115, + 116 + ] + }, + { + "teal": 94, + "source": 66, + "pc": [ + 117, + 118 + ] + }, + { + "teal": 95, + "source": 66, + "pc": [ + 119 + ] + }, + { + "teal": 96, + "source": 66, + "pc": [ + 120 + ] + }, + { + "teal": 97, + "source": 66, + "pc": [ + 121 + ] + }, + { + "teal": 98, + "source": 66, + "pc": [ + 122, + 123 + ] + }, + { + "teal": 104, + "source": 69, + "pc": [ + 124, + 125 + ] + }, + { + "teal": 105, + "source": 69, + "pc": [ + 126 + ] + }, + { + "teal": 106, + "source": 69, + "pc": [ + 127, + 128 + ] + }, + { + "teal": 107, + "source": 69, + "pc": [ + 129 + ] + }, + { + "teal": 108, + "source": 69, + "pc": [ + 130 + ] + }, + { + "teal": 109, + "source": 69, + "pc": [ + 131, + 132, + 133 + ] + }, + { + "teal": 110, + "source": 69, + "pc": [ + 134 + ] + }, + { + "teal": 111, + "source": 69, + "pc": [ + 135, + 136 + ] + }, + { + "teal": 112, + "source": 69, + "pc": [ + 137 + ] + }, + { + "teal": 113, + "source": 69, + "pc": [ + 138 + ] + }, + { + "teal": 114, + "source": 69, + "pc": [ + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148 + ] + }, + { + "teal": 115, + "source": 69, + "pc": [ + 149 + ] + }, + { + "teal": 116, + "source": 68, + "pc": [ + 150, + 151 + ] + }, + { + "teal": 120, + "source": 72, + "pc": [ + 152, + 153 + ] + }, + { + "teal": 121, + "source": 72, + "pc": [ + 154 + ] + }, + { + "teal": 122, + "source": 72, + "pc": [ + 155 + ] + }, + { + "teal": 123, + "source": 72, + "pc": [ + 156 + ] + }, + { + "teal": 124, + "source": 72, + "pc": [ + 157 + ] + }, + { + "teal": 125, + "source": 72, + "pc": [ + 158 + ] + }, + { + "teal": 129, + "source": 74, + "pc": [ + 159, + 160 + ] + }, + { + "teal": 130, + "source": 74, + "pc": [ + 161, + 162 + ] + }, + { + "teal": 131, + "source": 74, + "pc": [ + 163 + ] + }, + { + "teal": 135, + "source": 76, + "pc": [ + 164 + ] + }, + { + "teal": 136, + "source": 76, + "pc": [ + 165, + 166 + ] + }, + { + "teal": 137, + "source": 76, + "pc": [ + 167 + ] + }, + { + "teal": 138, + "source": 76, + "pc": [ + 168 + ] + }, + { + "teal": 139, + "source": 76, + "pc": [ + 169 + ] + }, + { + "teal": 147, + "source": 78, + "pc": [ + 170, + 171 + ] + }, + { + "teal": 148, + "source": 78, + "pc": [ + 172, + 173 + ] + }, + { + "teal": 149, + "source": 78, + "pc": [ + 174 + ] + }, + { + "teal": 150, + "source": 79, + "pc": [ + 175, + 176 + ] + }, + { + "teal": 151, + "source": 79, + "pc": [ + 177 + ] + }, + { + "teal": 152, + "source": 79, + "pc": [ + 178 + ] + }, + { + "teal": 153, + "source": 79, + "pc": [ + 179, + 180 + ] + }, + { + "teal": 154, + "source": 79, + "pc": [ + 181 + ] + }, + { + "teal": 155, + "source": 79, + "pc": [ + 182, + 183 + ] + }, + { + "teal": 156, + "source": 79, + "pc": [ + 184 + ] + }, + { + "teal": 157, + "source": 79, + "pc": [ + 185 + ] + }, + { + "teal": 158, + "source": 80, + "pc": [ + 186, + 187 + ] + }, + { + "teal": 159, + "source": 80, + "pc": [ + 188 + ] + }, + { + "teal": 160, + "source": 80, + "pc": [ + 189 + ] + }, + { + "teal": 161, + "source": 80, + "pc": [ + 190, + 191 + ] + }, + { + "teal": 162, + "source": 80, + "pc": [ + 192 + ] + }, + { + "teal": 163, + "source": 80, + "pc": [ + 193 + ] + }, + { + "teal": 164, + "source": 81, + "pc": [ + 194, + 195 + ] + }, + { + "teal": 165, + "source": 81, + "pc": [ + 196, + 197 + ] + }, + { + "teal": 166, + "source": 81, + "pc": [ + 198 + ] + }, + { + "teal": 167, + "source": 81, + "pc": [ + 199 + ] + }, + { + "teal": 168, + "source": 82, + "pc": [ + 200, + 201 + ] + }, + { + "teal": 169, + "source": 82, + "pc": [ + 202 + ] + }, + { + "teal": 170, + "source": 82, + "pc": [ + 203, + 204, + 205, + 206 + ] + }, + { + "teal": 171, + "source": 82, + "pc": [ + 207 + ] + }, + { + "teal": 172, + "source": 78, + "pc": [ + 208, + 209 + ] + }, + { + "teal": 176, + "source": 84, + "pc": [ + 210, + 211 + ] + }, + { + "teal": 177, + "source": 84, + "pc": [ + 212, + 213 + ] + }, + { + "teal": 178, + "source": 84, + "pc": [ + 214, + 215 + ] + }, + { + "teal": 179, + "source": 84, + "pc": [ + 216 + ] + }, + { + "teal": 180, + "source": 84, + "pc": [ + 217 + ] + }, + { + "teal": 184, + "source": 85, + "pc": [ + 218, + 219 + ] + }, + { + "teal": 185, + "source": 85, + "pc": [ + 220, + 221 + ] + }, + { + "teal": 186, + "source": 85, + "pc": [ + 222, + 223 + ] + }, + { + "teal": 187, + "source": 85, + "pc": [ + 224 + ] + }, + { + "teal": 188, + "source": 85, + "pc": [ + 225 + ] + }, + { + "teal": 189, + "source": 57, + "pc": [ + 226 + ] + }, + { + "teal": 194, + "source": 97, + "pc": [ + 227, + 228, + 229 + ] + }, + { + "teal": 195, + "source": 97, + "pc": [ + 230, + 231, + 232 + ] + }, + { + "teal": 198, + "source": 97, + "pc": [ + 233, + 234, + 235 + ] + }, + { + "teal": 199, + "source": 97, + "pc": [ + 236 + ] + }, + { + "teal": 202, + "source": 97, + "pc": [ + 237, + 238, + 239 + ] + }, + { + "teal": 203, + "source": 97, + "pc": [ + 240 + ] + }, + { + "teal": 206, + "source": 97, + "pc": [ + 241, + 242, + 243 + ] + }, + { + "teal": 207, + "source": 97, + "pc": [ + 244 + ] + }, + { + "teal": 208, + "source": 97, + "pc": [ + 245 + ] + }, + { + "teal": 209, + "source": 97, + "pc": [ + 246 + ] + }, + { + "teal": 210, + "source": 97, + "pc": [ + 247 + ] + }, + { + "teal": 213, + "source": 97, + "errorMessage": "argument 3 (pubKey) for upload must be a address", + "pc": [ + 248 + ] + }, + { + "teal": 216, + "source": 97, + "pc": [ + 249, + 250, + 251 + ] + }, + { + "teal": 217, + "source": 97, + "pc": [ + 252 + ] + }, + { + "teal": 218, + "source": 97, + "pc": [ + 253 + ] + }, + { + "teal": 230, + "source": 97, + "pc": [ + 254, + 255, + 256 + ] + }, + { + "teal": 233, + "source": 97, + "pc": [ + 257 + ] + }, + { + "teal": 237, + "source": 98, + "pc": [ + 258, + 259 + ] + }, + { + "teal": 238, + "source": 98, + "pc": [ + 260, + 261 + ] + }, + { + "teal": 239, + "source": 98, + "pc": [ + 262 + ] + }, + { + "teal": 240, + "source": 98, + "pc": [ + 263 + ] + }, + { + "teal": 244, + "source": 100, + "pc": [ + 264, + 265 + ] + }, + { + "teal": 245, + "source": 100, + "pc": [ + 266, + 267 + ] + }, + { + "teal": 249, + "source": 100, + "pc": [ + 268, + 269 + ] + }, + { + "teal": 250, + "source": 100, + "pc": [ + 270, + 271 + ] + }, + { + "teal": 251, + "source": 100, + "pc": [ + 272 + ] + }, + { + "teal": 252, + "source": 100, + "pc": [ + 273 + ] + }, + { + "teal": 253, + "source": 101, + "pc": [ + 274 + ] + }, + { + "teal": 254, + "source": 26, + "pc": [ + 275 + ] + }, + { + "teal": 255, + "source": 101, + "pc": [ + 276 + ] + }, + { + "teal": 256, + "source": 101, + "pc": [ + 277 + ] + }, + { + "teal": 260, + "source": 100, + "pc": [ + 278, + 279 + ] + }, + { + "teal": 261, + "source": 100, + "pc": [ + 280 + ] + }, + { + "teal": 262, + "source": 100, + "pc": [ + 281 + ] + }, + { + "teal": 263, + "source": 100, + "pc": [ + 282 + ] + }, + { + "teal": 264, + "source": 102, + "pc": [ + 283 + ] + }, + { + "teal": 265, + "source": 102, + "pc": [ + 284, + 285 + ] + }, + { + "teal": 266, + "source": 102, + "pc": [ + 286 + ] + }, + { + "teal": 267, + "source": 102, + "pc": [ + 287 + ] + }, + { + "teal": 268, + "source": 102, + "pc": [ + 288, + 289, + 290 + ] + }, + { + "teal": 269, + "source": 102, + "pc": [ + 291, + 292 + ] + }, + { + "teal": 270, + "source": 100, + "pc": [ + 293, + 294 + ] + }, + { + "teal": 271, + "source": 100, + "pc": [ + 295 + ] + }, + { + "teal": 272, + "source": 100, + "pc": [ + 296 + ] + }, + { + "teal": 273, + "source": 100, + "pc": [ + 297 + ] + }, + { + "teal": 274, + "source": 102, + "pc": [ + 298 + ] + }, + { + "teal": 275, + "source": 102, + "pc": [ + 299 + ] + }, + { + "teal": 276, + "source": 102, + "pc": [ + 300 + ] + }, + { + "teal": 279, + "source": 102, + "pc": [ + 301 + ] + }, + { + "teal": 284, + "source": 104, + "pc": [ + 302, + 303 + ] + }, + { + "teal": 285, + "source": 104, + "pc": [ + 304 + ] + }, + { + "teal": 286, + "source": 104, + "pc": [ + 305 + ] + }, + { + "teal": 287, + "source": 104, + "pc": [ + 306, + 307, + 308 + ] + }, + { + "teal": 292, + "source": 105, + "pc": [ + 309, + 310 + ] + }, + { + "teal": 293, + "source": 105, + "pc": [ + 311 + ] + }, + { + "teal": 294, + "source": 105, + "pc": [ + 312, + 313 + ] + }, + { + "teal": 295, + "source": 100, + "pc": [ + 314, + 315 + ] + }, + { + "teal": 296, + "source": 100, + "pc": [ + 316 + ] + }, + { + "teal": 297, + "source": 100, + "pc": [ + 317 + ] + }, + { + "teal": 298, + "source": 100, + "pc": [ + 318 + ] + }, + { + "teal": 299, + "source": 105, + "pc": [ + 319 + ] + }, + { + "teal": 300, + "source": 105, + "pc": [ + 320 + ] + }, + { + "teal": 301, + "source": 105, + "pc": [ + 321, + 322, + 323 + ] + }, + { + "teal": 302, + "source": 100, + "pc": [ + 324, + 325 + ] + }, + { + "teal": 303, + "source": 100, + "pc": [ + 326, + 327 + ] + }, + { + "teal": 304, + "source": 100, + "pc": [ + 328 + ] + }, + { + "teal": 305, + "source": 100, + "pc": [ + 329 + ] + }, + { + "teal": 306, + "source": 105, + "pc": [ + 330 + ] + }, + { + "teal": 307, + "source": 105, + "pc": [ + 331, + 332, + 333 + ] + }, + { + "teal": 310, + "source": 105, + "pc": [ + 334, + 335 + ] + }, + { + "teal": 313, + "source": 105, + "pc": [ + 336 + ] + }, + { + "teal": 314, + "source": 105, + "pc": [ + 337 + ] + }, + { + "teal": 319, + "source": 108, + "pc": [ + 338, + 339 + ] + }, + { + "teal": 320, + "source": 108, + "pc": [ + 340 + ] + }, + { + "teal": 321, + "source": 108, + "pc": [ + 341, + 342 + ] + }, + { + "teal": 322, + "source": 108, + "pc": [ + 343, + 344 + ] + }, + { + "teal": 323, + "source": 108, + "pc": [ + 345 + ] + }, + { + "teal": 324, + "source": 97, + "pc": [ + 346 + ] + }, + { + "teal": 329, + "source": 117, + "pc": [ + 347, + 348, + 349 + ] + }, + { + "teal": 330, + "source": 117, + "pc": [ + 350 + ] + }, + { + "teal": 331, + "source": 117, + "pc": [ + 351 + ] + }, + { + "teal": 332, + "source": 117, + "pc": [ + 352 + ] + }, + { + "teal": 333, + "source": 117, + "pc": [ + 353 + ] + }, + { + "teal": 336, + "source": 117, + "errorMessage": "argument 0 (pubKey) for finishUpload must be a address", + "pc": [ + 354 + ] + }, + { + "teal": 339, + "source": 117, + "pc": [ + 355, + 356, + 357 + ] + }, + { + "teal": 340, + "source": 117, + "pc": [ + 358 + ] + }, + { + "teal": 341, + "source": 117, + "pc": [ + 359 + ] + }, + { + "teal": 350, + "source": 117, + "pc": [ + 360, + 361, + 362 + ] + }, + { + "teal": 354, + "source": 118, + "pc": [ + 363, + 364 + ] + }, + { + "teal": 355, + "source": 118, + "pc": [ + 365, + 366 + ] + }, + { + "teal": 356, + "source": 118, + "pc": [ + 367 + ] + }, + { + "teal": 357, + "source": 118, + "pc": [ + 368 + ] + }, + { + "teal": 361, + "source": 120, + "pc": [ + 369, + 370 + ] + }, + { + "teal": 362, + "source": 120, + "pc": [ + 371, + 372 + ] + }, + { + "teal": 363, + "source": 120, + "pc": [ + 373, + 374, + 375 + ] + }, + { + "teal": 364, + "source": 120, + "pc": [ + 376 + ] + }, + { + "teal": 365, + "source": 117, + "pc": [ + 377 + ] + }, + { + "teal": 370, + "source": 128, + "pc": [ + 378, + 379, + 380 + ] + }, + { + "teal": 371, + "source": 128, + "pc": [ + 381 + ] + }, + { + "teal": 372, + "source": 128, + "pc": [ + 382 + ] + }, + { + "teal": 373, + "source": 128, + "pc": [ + 383 + ] + }, + { + "teal": 374, + "source": 128, + "pc": [ + 384 + ] + }, + { + "teal": 377, + "source": 128, + "errorMessage": "argument 0 (pubKey) for startDelete must be a address", + "pc": [ + 385 + ] + }, + { + "teal": 380, + "source": 128, + "pc": [ + 386, + 387, + 388 + ] + }, + { + "teal": 381, + "source": 128, + "pc": [ + 389 + ] + }, + { + "teal": 382, + "source": 128, + "pc": [ + 390 + ] + }, + { + "teal": 390, + "source": 128, + "pc": [ + 391, + 392, + 393 + ] + }, + { + "teal": 393, + "source": 128, + "pc": [ + 394 + ] + }, + { + "teal": 397, + "source": 129, + "pc": [ + 395, + 396 + ] + }, + { + "teal": 398, + "source": 129, + "pc": [ + 397, + 398 + ] + }, + { + "teal": 399, + "source": 129, + "pc": [ + 399 + ] + }, + { + "teal": 400, + "source": 129, + "pc": [ + 400 + ] + }, + { + "teal": 404, + "source": 131, + "pc": [ + 401, + 402 + ] + }, + { + "teal": 405, + "source": 131, + "pc": [ + 403, + 404 + ] + }, + { + "teal": 409, + "source": 131, + "pc": [ + 405, + 406 + ] + }, + { + "teal": 410, + "source": 131, + "pc": [ + 407, + 408 + ] + }, + { + "teal": 411, + "source": 131, + "pc": [ + 409 + ] + }, + { + "teal": 412, + "source": 131, + "pc": [ + 410 + ] + }, + { + "teal": 413, + "source": 132, + "pc": [ + 411 + ] + }, + { + "teal": 414, + "source": 29, + "pc": [ + 412 + ] + }, + { + "teal": 415, + "source": 132, + "pc": [ + 413 + ] + }, + { + "teal": 416, + "source": 132, + "pc": [ + 414 + ] + }, + { + "teal": 420, + "source": 131, + "pc": [ + 415, + 416 + ] + }, + { + "teal": 421, + "source": 131, + "pc": [ + 417, + 418 + ] + }, + { + "teal": 422, + "source": 131, + "pc": [ + 419, + 420, + 421 + ] + }, + { + "teal": 423, + "source": 131, + "pc": [ + 422 + ] + }, + { + "teal": 424, + "source": 128, + "pc": [ + 423 + ] + }, + { + "teal": 429, + "source": 143, + "pc": [ + 424, + 425, + 426 + ] + }, + { + "teal": 430, + "source": 143, + "pc": [ + 427 + ] + }, + { + "teal": 433, + "source": 143, + "pc": [ + 428, + 429, + 430 + ] + }, + { + "teal": 434, + "source": 143, + "pc": [ + 431 + ] + }, + { + "teal": 435, + "source": 143, + "pc": [ + 432 + ] + }, + { + "teal": 436, + "source": 143, + "pc": [ + 433 + ] + }, + { + "teal": 437, + "source": 143, + "pc": [ + 434 + ] + }, + { + "teal": 440, + "source": 143, + "errorMessage": "argument 1 (pubKey) for deleteData must be a address", + "pc": [ + 435 + ] + }, + { + "teal": 443, + "source": 143, + "pc": [ + 436, + 437, + 438 + ] + }, + { + "teal": 444, + "source": 143, + "pc": [ + 439 + ] + }, + { + "teal": 445, + "source": 143, + "pc": [ + 440 + ] + }, + { + "teal": 454, + "source": 143, + "pc": [ + 441, + 442, + 443 + ] + }, + { + "teal": 457, + "source": 143, + "pc": [ + 444 + ] + }, + { + "teal": 458, + "source": 143, + "pc": [ + 445 + ] + }, + { + "teal": 462, + "source": 144, + "pc": [ + 446, + 447 + ] + }, + { + "teal": 463, + "source": 144, + "pc": [ + 448, + 449 + ] + }, + { + "teal": 464, + "source": 144, + "pc": [ + 450 + ] + }, + { + "teal": 465, + "source": 144, + "pc": [ + 451 + ] + }, + { + "teal": 469, + "source": 146, + "pc": [ + 452, + 453 + ] + }, + { + "teal": 470, + "source": 146, + "pc": [ + 454, + 455 + ] + }, + { + "teal": 474, + "source": 146, + "pc": [ + 456, + 457 + ] + }, + { + "teal": 475, + "source": 146, + "pc": [ + 458, + 459 + ] + }, + { + "teal": 476, + "source": 146, + "pc": [ + 460 + ] + }, + { + "teal": 477, + "source": 146, + "pc": [ + 461 + ] + }, + { + "teal": 478, + "source": 147, + "pc": [ + 462 + ] + }, + { + "teal": 479, + "source": 32, + "pc": [ + 463, + 464 + ] + }, + { + "teal": 480, + "source": 147, + "pc": [ + 465 + ] + }, + { + "teal": 481, + "source": 147, + "pc": [ + 466 + ] + }, + { + "teal": 485, + "source": 146, + "pc": [ + 467, + 468 + ] + }, + { + "teal": 486, + "source": 146, + "pc": [ + 469 + ] + }, + { + "teal": 487, + "source": 146, + "pc": [ + 470 + ] + }, + { + "teal": 488, + "source": 146, + "pc": [ + 471 + ] + }, + { + "teal": 489, + "source": 148, + "pc": [ + 472 + ] + }, + { + "teal": 490, + "source": 148, + "pc": [ + 473, + 474 + ] + }, + { + "teal": 491, + "source": 148, + "pc": [ + 475 + ] + }, + { + "teal": 492, + "source": 148, + "pc": [ + 476 + ] + }, + { + "teal": 493, + "source": 148, + "pc": [ + 477, + 478, + 479 + ] + }, + { + "teal": 494, + "source": 148, + "pc": [ + 480, + 481 + ] + }, + { + "teal": 495, + "source": 146, + "pc": [ + 482, + 483 + ] + }, + { + "teal": 496, + "source": 146, + "pc": [ + 484 + ] + }, + { + "teal": 497, + "source": 146, + "pc": [ + 485 + ] + }, + { + "teal": 498, + "source": 146, + "pc": [ + 486 + ] + }, + { + "teal": 499, + "source": 148, + "pc": [ + 487 + ] + }, + { + "teal": 500, + "source": 148, + "pc": [ + 488 + ] + }, + { + "teal": 501, + "source": 148, + "pc": [ + 489 + ] + }, + { + "teal": 504, + "source": 148, + "pc": [ + 490 + ] + }, + { + "teal": 509, + "source": 150, + "pc": [ + 491, + 492 + ] + }, + { + "teal": 510, + "source": 146, + "pc": [ + 493, + 494 + ] + }, + { + "teal": 511, + "source": 146, + "pc": [ + 495 + ] + }, + { + "teal": 512, + "source": 146, + "pc": [ + 496 + ] + }, + { + "teal": 513, + "source": 146, + "pc": [ + 497 + ] + }, + { + "teal": 514, + "source": 150, + "pc": [ + 498 + ] + }, + { + "teal": 515, + "source": 150, + "pc": [ + 499 + ] + }, + { + "teal": 516, + "source": 150, + "pc": [ + 500, + 501, + 502 + ] + }, + { + "teal": 521, + "source": 146, + "pc": [ + 503, + 504 + ] + }, + { + "teal": 522, + "source": 146, + "pc": [ + 505, + 506 + ] + }, + { + "teal": 523, + "source": 146, + "pc": [ + 507 + ] + }, + { + "teal": 524, + "source": 146, + "pc": [ + 508 + ] + }, + { + "teal": 525, + "source": 150, + "pc": [ + 509 + ] + }, + { + "teal": 526, + "source": 150, + "pc": [ + 510, + 511 + ] + }, + { + "teal": 527, + "source": 150, + "pc": [ + 512 + ] + }, + { + "teal": 528, + "source": 150, + "pc": [ + 513 + ] + }, + { + "teal": 529, + "source": 150, + "pc": [ + 514 + ] + }, + { + "teal": 530, + "source": 150, + "pc": [ + 515 + ] + }, + { + "teal": 535, + "source": 152, + "pc": [ + 516, + 517 + ] + }, + { + "teal": 536, + "source": 152, + "pc": [ + 518, + 519 + ] + }, + { + "teal": 537, + "source": 152, + "pc": [ + 520 + ] + }, + { + "teal": 538, + "source": 152, + "pc": [ + 521, + 522 + ] + }, + { + "teal": 542, + "source": 154, + "pc": [ + 523, + 524 + ] + }, + { + "teal": 543, + "source": 154, + "pc": [ + 525 + ] + }, + { + "teal": 544, + "source": 154, + "pc": [ + 526 + ] + }, + { + "teal": 549, + "source": 156, + "pc": [ + 527, + 528 + ] + }, + { + "teal": 550, + "source": 146, + "pc": [ + 529, + 530 + ] + }, + { + "teal": 551, + "source": 146, + "pc": [ + 531 + ] + }, + { + "teal": 552, + "source": 146, + "pc": [ + 532 + ] + }, + { + "teal": 553, + "source": 146, + "pc": [ + 533 + ] + }, + { + "teal": 554, + "source": 156, + "pc": [ + 534 + ] + }, + { + "teal": 555, + "source": 156, + "pc": [ + 535 + ] + }, + { + "teal": 556, + "source": 156, + "pc": [ + 536, + 537, + 538 + ] + }, + { + "teal": 561, + "source": 156, + "pc": [ + 539, + 540 + ] + }, + { + "teal": 562, + "source": 156, + "pc": [ + 541 + ] + }, + { + "teal": 563, + "source": 156, + "pc": [ + 542, + 543, + 544 + ] + }, + { + "teal": 568, + "source": 157, + "pc": [ + 545, + 546 + ] + }, + { + "teal": 569, + "source": 157, + "pc": [ + 547, + 548 + ] + }, + { + "teal": 570, + "source": 157, + "pc": [ + 549 + ] + }, + { + "teal": 571, + "source": 146, + "pc": [ + 550, + 551 + ] + }, + { + "teal": 572, + "source": 146, + "pc": [ + 552, + 553 + ] + }, + { + "teal": 573, + "source": 146, + "pc": [ + 554 + ] + }, + { + "teal": 581, + "source": 159, + "pc": [ + 555 + ] + }, + { + "teal": 582, + "source": 159, + "pc": [ + 556 + ] + }, + { + "teal": 583, + "source": 159, + "pc": [ + 557, + 558 + ] + }, + { + "teal": 587, + "source": 160, + "pc": [ + 559, + 560 + ] + }, + { + "teal": 588, + "source": 160, + "pc": [ + 561, + 562 + ] + }, + { + "teal": 589, + "source": 160, + "pc": [ + 563, + 564 + ] + }, + { + "teal": 590, + "source": 160, + "pc": [ + 565 + ] + }, + { + "teal": 591, + "source": 160, + "pc": [ + 566 + ] + }, + { + "teal": 592, + "source": 160, + "pc": [ + 567, + 568 + ] + }, + { + "teal": 596, + "source": 161, + "pc": [ + 569, + 570 + ] + }, + { + "teal": 597, + "source": 161, + "pc": [ + 571, + 572 + ] + }, + { + "teal": 600, + "source": 159, + "pc": [ + 573 + ] + }, + { + "teal": 601, + "source": 159, + "pc": [ + 574, + 575 + ] + }, + { + "teal": 604, + "source": 159, + "pc": [ + 576 + ] + }, + { + "teal": 605, + "source": 143, + "pc": [ + 577 + ] + }, + { + "teal": 610, + "source": 168, + "pc": [ + 578, + 579, + 580 + ] + }, + { + "teal": 611, + "source": 168, + "pc": [ + 581 + ] + }, + { + "teal": 612, + "source": 168, + "pc": [ + 582 + ] + }, + { + "teal": 618, + "source": 168, + "pc": [ + 583, + 584, + 585 + ] + }, + { + "teal": 622, + "source": 169, + "pc": [ + 586, + 587 + ] + }, + { + "teal": 623, + "source": 169, + "pc": [ + 588, + 589 + ] + }, + { + "teal": 624, + "source": 169, + "pc": [ + 590 + ] + }, + { + "teal": 625, + "source": 169, + "pc": [ + 591 + ] + }, + { + "teal": 626, + "source": 168, + "pc": [ + 592 + ] + }, + { + "teal": 631, + "source": 178, + "pc": [ + 593, + 594, + 595 + ] + }, + { + "teal": 632, + "source": 178, + "pc": [ + 596 + ] + }, + { + "teal": 633, + "source": 178, + "pc": [ + 597 + ] + }, + { + "teal": 642, + "source": 178, + "pc": [ + 598, + 599, + 600 + ] + }, + { + "teal": 643, + "source": 178, + "pc": [ + 601 + ] + }, + { + "teal": 646, + "source": 38, + "pc": [ + 602 + ] + }, + { + "teal": 647, + "source": 38, + "pc": [ + 603 + ] + }, + { + "teal": 650, + "source": 38, + "pc": [ + 604, + 605, + 606, + 607, + 608, + 609 + ] + }, + { + "teal": 651, + "source": 38, + "pc": [ + 610, + 611, + 612 + ] + }, + { + "teal": 652, + "source": 38, + "pc": [ + 613, + 614, + 615, + 616 + ] + }, + { + "teal": 655, + "source": 38, + "errorMessage": "this contract does not implement the given ABI method for create NoOp", + "pc": [ + 617 + ] + }, + { + "teal": 658, + "source": 38, + "pc": [ + 618, + 619, + 620, + 621, + 622, + 623 + ] + }, + { + "teal": 659, + "source": 38, + "pc": [ + 624, + 625, + 626, + 627, + 628, + 629 + ] + }, + { + "teal": 660, + "source": 38, + "pc": [ + 630, + 631, + 632, + 633, + 634, + 635 + ] + }, + { + "teal": 661, + "source": 38, + "pc": [ + 636, + 637, + 638, + 639, + 640, + 641 + ] + }, + { + "teal": 662, + "source": 38, + "pc": [ + 642, + 643, + 644, + 645, + 646, + 647 + ] + }, + { + "teal": 663, + "source": 38, + "pc": [ + 648, + 649, + 650, + 651, + 652, + 653 + ] + }, + { + "teal": 664, + "source": 38, + "pc": [ + 654, + 655, + 656 + ] + }, + { + "teal": 665, + "source": 38, + "pc": [ + 657, + 658, + 659, + 660, + 661, + 662, + 663, + 664, + 665, + 666, + 667, + 668, + 669, + 670 + ] + }, + { + "teal": 668, + "source": 38, + "errorMessage": "this contract does not implement the given ABI method for call NoOp", + "pc": [ + 671 + ] + }, + { + "teal": 671, + "source": 38, + "pc": [ + 672, + 673, + 674, + 675, + 676, + 677 + ] + }, + { + "teal": 672, + "source": 38, + "pc": [ + 678, + 679, + 680 + ] + }, + { + "teal": 673, + "source": 38, + "pc": [ + 681, + 682, + 683, + 684 + ] + }, + { + "teal": 676, + "source": 38, + "errorMessage": "this contract does not implement the given ABI method for call UpdateApplication", + "pc": [ + 685 + ] + } + ], + "source": { + "approval": "#pragma version 10

// This TEAL was generated by TEALScript v0.96.0
// https://github.com/algorandfoundation/TEALScript

// This contract is compliant with and/or implements the following ARCs: [ ARC4 ]

// The following ten lines of TEAL handle initial program flow
// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed
// Here, action refers to the OnComplete in combination with whether the app is being created or called
// Every possible action for this contract is represented in the switch statement
// If the action is not implemented in the contract, its respective branch will be "*NOT_IMPLEMENTED" which just contains "err"
txn ApplicationID
!
int 6
*
txn OnCompletion
+
switch *call_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *call_UpdateApplication *NOT_IMPLEMENTED *create_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED

*NOT_IMPLEMENTED:
	// The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?
	err

// startUpload(address,uint64,uint64,pay)void
*abi_route_startUpload:
	// mbrPayment: pay
	txn GroupIndex
	int 1
	-
	dup
	gtxns TypeEnum
	int pay
	==

	// argument 0 (mbrPayment) for startUpload must be a pay transaction
	assert

	// endBoxSize: uint64
	txna ApplicationArgs 3
	btoi

	// numBoxes: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 3 (pubKey) for startUpload must be a address
	assert

	// execute startUpload(address,uint64,uint64,pay)void
	callsub startUpload
	int 1
	return

// startUpload(pubKey: Address, numBoxes: uint64, endBoxSize: uint64, mbrPayment: PayTxn): void
//
//
// Allocate boxes to begin data upload process
//
// @param pubKey The pubkey of the DID
// @param numBoxes The number of boxes that the data will take up
// @param endBoxSize The size of the last box
// @param mbrPayment Payment from the uploader to cover the box MBR
startUpload:
	proto 4 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x
	dupn 3

	// contracts/algo-did.algo.ts:63
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:65
	// startBox = this.currentIndex.value
	byte 0x63757272656e74496e646578 // "currentIndex"
	app_global_get
	frame_bury 0 // startBox: uint64

	// contracts/algo-did.algo.ts:66
	// endBox = startBox + numBoxes - 1
	frame_dig 0 // startBox: uint64
	frame_dig -2 // numBoxes: uint64
	+
	int 1
	-
	frame_bury 1 // endBox: uint64

	// contracts/algo-did.algo.ts:68
	// metadata: Metadata = {
	//       start: startBox, end: endBox, status: UPLOADING, endSize: endBoxSize, lastDeleted: 0,
	//     }
	frame_dig 0 // startBox: uint64
	itob
	frame_dig 1 // endBox: uint64
	itob
	concat
	byte 0x00
	concat
	frame_dig -3 // endBoxSize: uint64
	itob
	concat
	byte 0x0000000000000000
	concat
	frame_bury 2 // metadata: Metadata

	// contracts/algo-did.algo.ts:72
	// assert(!this.metadata(pubKey).exists)
	frame_dig -1 // pubKey: Address
	box_len
	swap
	pop
	!
	assert

	// contracts/algo-did.algo.ts:74
	// this.metadata(pubKey).value = metadata
	frame_dig -1 // pubKey: Address
	frame_dig 2 // metadata: Metadata
	box_put

	// contracts/algo-did.algo.ts:76
	// this.currentIndex.value = endBox + 1
	byte 0x63757272656e74496e646578 // "currentIndex"
	frame_dig 1 // endBox: uint64
	int 1
	+
	app_global_put

	// contracts/algo-did.algo.ts:78
	// totalCost = numBoxes * COST_PER_BOX // cost of data boxes
	//     + (numBoxes - 1) * MAX_BOX_SIZE * COST_PER_BYTE // cost of data
	//     + numBoxes * 8 * COST_PER_BYTE // cost of data keys
	//     + endBoxSize * COST_PER_BYTE // cost of last data box
	//     + COST_PER_BOX + (8 + 8 + 1 + 8 + 32 + 8) * COST_PER_BYTE
	frame_dig -2 // numBoxes: uint64
	int 2500
	*
	frame_dig -2 // numBoxes: uint64
	int 1
	-
	int 32768
	*
	int 400
	*
	+
	frame_dig -2 // numBoxes: uint64
	int 8
	*
	int 400
	*
	+
	frame_dig -3 // endBoxSize: uint64
	int 400
	*
	+
	int 2500
	+
	int 26000
	+
	frame_bury 3 // totalCost: uint64

	// contracts/algo-did.algo.ts:84
	// assert(mbrPayment.amount === totalCost)
	frame_dig -4 // mbrPayment: PayTxn
	gtxns Amount
	frame_dig 3 // totalCost: uint64
	==
	assert

	// contracts/algo-did.algo.ts:85
	// assert(mbrPayment.receiver === this.app.address)
	frame_dig -4 // mbrPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==
	assert
	retsub

// upload(address,uint64,uint64,byte[])void
*abi_route_upload:
	// data: byte[]
	txna ApplicationArgs 4
	extract 2 0

	// offset: uint64
	txna ApplicationArgs 3
	btoi

	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 3 (pubKey) for upload must be a address
	assert

	// execute upload(address,uint64,uint64,byte[])void
	callsub upload
	int 1
	return

// upload(pubKey: Address, boxIndex: uint64, offset: uint64, data: bytes): void
//
//
// Upload data to a specific offset in a box
//
// @param pubKey The pubkey of the DID
// @param boxIndex The index of the box to upload the given chunk of data to
// @param offset The offset within the box to start writing the data
// @param data The data to write
upload:
	proto 4 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x

	// contracts/algo-did.algo.ts:98
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:100
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: Address
	frame_bury 0 // storage key//metadata

	// contracts/algo-did.algo.ts:101
	// assert(metadata.status === UPLOADING)
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	int 1
	box_extract
	btoi
	int 0
	==
	assert

	// contracts/algo-did.algo.ts:102
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -1 // pubKey: Address
	int 0
	int 8
	box_extract
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz *skip_and0
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	<=
	&&

*skip_and0:
	assert

	// *if0_condition
	// contracts/algo-did.algo.ts:104
	// offset === 0
	frame_dig -3 // offset: uint64
	int 0
	==
	bz *if0_end

	// *if0_consequent
	// contracts/algo-did.algo.ts:105
	// this.dataBoxes(boxIndex).create(boxIndex === metadata.end ? metadata.endSize : MAX_BOX_SIZE)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	==
	bz *ternary0_false
	frame_dig -1 // pubKey: Address
	int 17 // headOffset
	int 8
	box_extract
	btoi
	b *ternary0_end

*ternary0_false:
	int 32768

*ternary0_end:
	box_create
	pop

*if0_end:
	// contracts/algo-did.algo.ts:108
	// this.dataBoxes(boxIndex).replace(offset, data)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -3 // offset: uint64
	frame_dig -4 // data: bytes
	box_replace
	retsub

// finishUpload(address)void
*abi_route_finishUpload:
	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 0 (pubKey) for finishUpload must be a address
	assert

	// execute finishUpload(address)void
	callsub finishUpload
	int 1
	return

// finishUpload(pubKey: Address): void
//
//
// Mark uploading as false
//
// @param pubKey The address of the DID
finishUpload:
	proto 1 0

	// contracts/algo-did.algo.ts:118
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:120
	// this.metadata(pubKey).value.status = READY
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	byte 0x01
	box_replace
	retsub

// startDelete(address)void
*abi_route_startDelete:
	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 0 (pubKey) for startDelete must be a address
	assert

	// execute startDelete(address)void
	callsub startDelete
	int 1
	return

// startDelete(pubKey: Address): void
//
// Starts the deletion process for the data associated with a DID
//
// @param pubKey The address of the DID
startDelete:
	proto 1 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x

	// contracts/algo-did.algo.ts:129
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:131
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: Address
	frame_bury 0 // storage key//metadata

	// contracts/algo-did.algo.ts:132
	// assert(metadata.status === READY)
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	int 1
	box_extract
	btoi
	int 1
	==
	assert

	// contracts/algo-did.algo.ts:134
	// metadata.status = DELETING
	frame_dig 0 // storage key//metadata
	int 16 // headOffset
	byte 0x02
	box_replace
	retsub

// deleteData(address,uint64)void
*abi_route_deleteData:
	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 1 (pubKey) for deleteData must be a address
	assert

	// execute deleteData(address,uint64)void
	callsub deleteData
	int 1
	return

// deleteData(pubKey: Address, boxIndex: uint64): void
//
// Deletes a box of data
//
// @param pubKey The address of the DID
// @param boxIndex The index of the box to delete
deleteData:
	proto 2 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x
	dup

	// contracts/algo-did.algo.ts:144
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:146
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: Address
	frame_bury 0 // storage key//metadata

	// contracts/algo-did.algo.ts:147
	// assert(metadata.status === DELETING)
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	int 1
	box_extract
	btoi
	int 2
	==
	assert

	// contracts/algo-did.algo.ts:148
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -1 // pubKey: Address
	int 0
	int 8
	box_extract
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz *skip_and1
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	<=
	&&

*skip_and1:
	assert

	// *if1_condition
	// contracts/algo-did.algo.ts:150
	// boxIndex !== metadata.start
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 0
	int 8
	box_extract
	btoi
	!=
	bz *if1_end

	// *if1_consequent
	// contracts/algo-did.algo.ts:150
	// assert(metadata.lastDeleted === boxIndex - 1)
	frame_dig -1 // pubKey: Address
	int 25 // headOffset
	int 8
	box_extract
	btoi
	frame_dig -2 // boxIndex: uint64
	int 1
	-
	==
	assert

*if1_end:
	// contracts/algo-did.algo.ts:152
	// preMBR = globals.currentApplicationAddress.minBalance
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	pop
	frame_bury 1 // preMBR: uint64

	// contracts/algo-did.algo.ts:154
	// this.dataBoxes(boxIndex).delete()
	frame_dig -2 // boxIndex: uint64
	itob
	box_del

	// *if2_condition
	// contracts/algo-did.algo.ts:156
	// boxIndex === metadata.end
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	==
	bz *if2_else

	// *if2_consequent
	// contracts/algo-did.algo.ts:156
	// this.metadata(pubKey).delete()
	frame_dig -1 // pubKey: Address
	box_del
	b *if2_end

*if2_else:
	// contracts/algo-did.algo.ts:157
	// metadata.lastDeleted = boxIndex
	int 25 // headOffset
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig 0 // storage key//metadata
	cover 2
	box_replace

*if2_end:
	// contracts/algo-did.algo.ts:159
	// sendPayment({
	//       amount: preMBR - globals.currentApplicationAddress.minBalance,
	//       receiver: this.txn.sender,
	//     })
	itxn_begin
	int pay
	itxn_field TypeEnum

	// contracts/algo-did.algo.ts:160
	// amount: preMBR - globals.currentApplicationAddress.minBalance
	frame_dig 1 // preMBR: uint64
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	pop
	-
	itxn_field Amount

	// contracts/algo-did.algo.ts:161
	// receiver: this.txn.sender
	txn Sender
	itxn_field Receiver

	// Fee field not set, defaulting to 0
	int 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// updateApplication()void
*abi_route_updateApplication:
	// execute updateApplication()void
	callsub updateApplication
	int 1
	return

// updateApplication(): void
//
// Allow the contract to be updated by the creator
updateApplication:
	proto 0 0

	// contracts/algo-did.algo.ts:169
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert
	retsub

// dummy()void
*abi_route_dummy:
	// execute dummy()void
	callsub dummy
	int 1
	return

// dummy(): void
//
// Dummy function to add extra box references for deleteData.
// Boxes are 32k, but a single app call can only inlcude enough references to read/write 8k
// at a time. Thus when a box is deleted, we need to add additional dummy calls with box
// references to increase the total read/write budget to 32k.
dummy:
	proto 0 0
	retsub

*abi_route_createApplication:
	int 1
	return

*create_NoOp:
	method "createApplication()void"
	txna ApplicationArgs 0
	match *abi_route_createApplication

	// this contract does not implement the given ABI method for create NoOp
	err

*call_NoOp:
	method "startUpload(address,uint64,uint64,pay)void"
	method "upload(address,uint64,uint64,byte[])void"
	method "finishUpload(address)void"
	method "startDelete(address)void"
	method "deleteData(address,uint64)void"
	method "dummy()void"
	txna ApplicationArgs 0
	match *abi_route_startUpload *abi_route_upload *abi_route_finishUpload *abi_route_startDelete *abi_route_deleteData *abi_route_dummy

	// this contract does not implement the given ABI method for call NoOp
	err

*call_UpdateApplication:
	method "updateApplication()void"
	txna ApplicationArgs 0
	match *abi_route_updateApplication

	// this contract does not implement the given ABI method for call UpdateApplication
	err", + "clear": "I3ByYWdtYSB2ZXJzaW9uIDEw" + }, + "byteCode": { + "approval": "CiAJAQgAIBCQA8QTgIACGSYCAAxjdXJyZW50SW5kZXgxGBSBBgsxGQiNDAInAAAAAAAAAl0AAAIZAAAAAAAAAAAAAAAxFiIJSTgQIhJENhoDFzYaAhc2GgFJFSUSRIgAAiJDigQAKEcDMQAyCRJEKWSMAIsAi/4IIgmMAYsAFosBFlCAAQBQi/0WUIAIAAAAAAAAAABQjAKL/71MSBREi/+LAr8piwEiCGeL/iEGC4v+IgkhBwshBQsIi/4jCyEFCwiL/SEFCwghBgiBkMsBCIwDi/w4CIsDEkSL/DgHMgoSRIk2GgRXAgA2GgMXNhoCFzYaAUkVJRJEiAACIkOKBAAoMQAyCRJEi/+MAIv/IQQiuhckEkSL/yQjuheL/g5JQQAKi/6L/yMjuhcOEESL/SQSQQAdi/4Wi/6L/yMjuhcSQQAKi/+BESO6F0IAAiEHuUiL/haL/Yv8u4k2GgFJFSUSRIgAAiJDigEAMQAyCRJEi/8hBIABAbuJNhoBSRUlEkSIAAIiQ4oBACgxADIJEkSL/4wAi/8hBCK6FyISRIsAIQSAAQK7iTYaAhc2GgFJFSUSRIgAAiJDigIAKEkxADIJEkSL/4wAi/8hBCK6F4ECEkSL/yQjuheL/g5JQQAKi/6L/yMjuhcOEESL/ov/JCO6FxNBAA2L/yEII7oXi/4iCRJEMgpzAUiMAYv+FryL/ov/IyO6FxJBAAaL/7xCAAohCIv+FosATgK7sSKyEIsBMgpzAUgJsggxALIHJLIBs4mIAAIiQ4oAADEAMgkSRImIAAIiQ4oAAIkiQ4AEuER7NjYaAI4B//EAgARWXGddgARNscQYgAQOeHJXgAS9LITigARokbqQgASjDOf/NhoAjgb9pf5E/rz+2/8J/7IAgARG92UzNhoAjgH/lQA=", + "clear": "Cg==" + }, + "compilerInfo": { + "compiler": "algod", + "compilerVersion": { + "major": 3, + "minor": 24, + "patch": 0, + "commitHash": "5c2cf06d" + } + } +} \ No newline at end of file diff --git a/client/internal/contracts/AlgoDID.clear.teal b/client/internal/contracts/AlgoDID.clear.teal index 6bbec50..e9f1d65 100644 --- a/client/internal/contracts/AlgoDID.clear.teal +++ b/client/internal/contracts/AlgoDID.clear.teal @@ -1,2 +1 @@ -#pragma version 9 -int 1 \ No newline at end of file +#pragma version 10 \ No newline at end of file diff --git a/client/internal/contracts/AlgoDID.json b/client/internal/contracts/AlgoDID.json index 2f2a1be..a3317c5 100644 --- a/client/internal/contracts/AlgoDID.json +++ b/client/internal/contracts/AlgoDID.json @@ -74,7 +74,7 @@ } }, "source": { - "approval": "#pragma version 9

// This TEAL was generated by TEALScript v0.51.1
// https://github.com/algorand-devrel/TEALScript

// This contract is compliant with and/or implements the following ARCs: [ ARC4 ]

// The following ten lines of TEAL handle initial program flow
// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed
// Here, action refers to the OnComplete in combination with whether the app is being created or called
// Every possible action for this contract is represented in the switch statement
// If the action is not implmented in the contract, its repsective branch will be "NOT_IMPLMENTED" which just contains "err"
txn ApplicationID
int 0
>
int 6
*
txn OnCompletion
+
switch create_NoOp NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED call_NoOp NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED call_UpdateApplication

NOT_IMPLEMENTED:
	err

// startUpload(pay,uint64,uint64,address)void
//
// 
// Allocate boxes to begin data upload process
// 
// @param pubKey The pubkey of the DID
// @param numBoxes The number of boxes that the data will take up
// @param endBoxSize The size of the last box
// @param mbrPayment Payment from the uploader to cover the box MBR
abi_route_startUpload:
	byte 0x; dupn 3 // push empty bytes to fill the stack frame for this subroutine's local variables

	// mbrPayment: pay
	txn GroupIndex
	int 1
	-
	dup
	gtxns TypeEnum
	int pay
	==
	assert

	// endBoxSize: uint64
	txna ApplicationArgs 3
	btoi

	// numBoxes: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute startUpload(pay,uint64,uint64,address)void
	callsub startUpload
	int 1
	return

startUpload:
	proto 8 0

	// contracts/algo-did.algo.ts:64
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:66
	// startBox = this.currentIndex.value
	byte 0x63757272656e74496e646578 // "currentIndex"
	app_global_get
	frame_bury -5 // startBox: uint64

	// contracts/algo-did.algo.ts:67
	// endBox = startBox + numBoxes - 1
	frame_dig -5 // startBox: uint64
	frame_dig -2 // numBoxes: uint64
	+
	int 1
	-
	frame_bury -6 // endBox: uint64

	// contracts/algo-did.algo.ts:69
	// metadata: Metadata = {
	//       start: startBox,
	//       end: endBox,
	//       status: UPLOADING,
	//       endSize: endBoxSize,
	//       lastDeleted: 0,
	//     }
	frame_dig -5 // startBox: uint64
	itob
	frame_dig -6 // endBox: uint64
	itob
	concat
	byte 0x00
	byte 0x00
	bitlen
	int 8
	<=
	assert
	byte 0xFF
	b&
	concat
	frame_dig -3 // endBoxSize: uint64
	itob
	concat
	byte 0x0000000000000000
	concat
	frame_bury -7 // metadata: Metadata

	// contracts/algo-did.algo.ts:77
	// assert(!this.metadata(pubKey).exists)
	frame_dig -1 // pubKey: address
	box_len
	swap
	pop
	!
	assert

	// contracts/algo-did.algo.ts:79
	// this.metadata(pubKey).value = metadata
	frame_dig -1 // pubKey: address
	frame_dig -7 // metadata: Metadata
	box_put

	// contracts/algo-did.algo.ts:81
	// this.currentIndex.value = endBox + 1
	byte 0x63757272656e74496e646578 // "currentIndex"
	frame_dig -6 // endBox: uint64
	int 1
	+
	app_global_put

	// contracts/algo-did.algo.ts:83
	// totalCost = numBoxes * COST_PER_BOX + // cost of data boxes
	//       (numBoxes - 1) * MAX_BOX_SIZE * COST_PER_BYTE + // cost of data
	//       numBoxes * 8 * COST_PER_BYTE + // cost of data keys
	//       endBoxSize * COST_PER_BYTE + // cost of last data box
	//       COST_PER_BOX +
	//       (8 + 8 + 1 + 8 + 32 + 8) * COST_PER_BYTE
	frame_dig -2 // numBoxes: uint64
	int 2500
	*
	frame_dig -2 // numBoxes: uint64
	int 1
	-
	int 32768
	*
	int 400
	*
	+
	frame_dig -2 // numBoxes: uint64
	int 8
	*
	int 400
	*
	+
	frame_dig -3 // endBoxSize: uint64
	int 400
	*
	+
	int 2500
	+
	int 26000
	+
	frame_bury -8 // totalCost: uint64

	// contracts/algo-did.algo.ts:90
	// assert(mbrPayment.amount === totalCost)
	frame_dig -4 // mbrPayment: pay
	gtxns Amount
	frame_dig -8 // totalCost: uint64
	==
	assert

	// contracts/algo-did.algo.ts:91
	// assert(mbrPayment.receiver === this.app.address)
	frame_dig -4 // mbrPayment: pay
	gtxns Receiver
	global CurrentApplicationAddress
	==
	assert
	retsub

// upload(bytes,uint64,uint64,address)void
//
// 
// Upload data to a specific offset in a box
// 
// @param pubKey The pubkey of the DID
// @param boxIndex The index of the box to upload the given chunk of data to
// @param offset The offset within the box to start writing the data
// @param data The data to write
abi_route_upload:
	byte 0x // push empty bytes to fill the stack frame for this subroutine's local variables

	// data: byte[]
	txna ApplicationArgs 4
	extract 2 0

	// offset: uint64
	txna ApplicationArgs 3
	btoi

	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute upload(bytes,uint64,uint64,address)void
	callsub upload
	int 1
	return

upload:
	proto 5 0

	// contracts/algo-did.algo.ts:104
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:106
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: address
	frame_bury -5 // storage key//metadata

	// contracts/algo-did.algo.ts:107
	// assert(metadata.status === UPLOADING)
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 16 1
	byte 0x0000000000000000
	b==
	assert

	// contracts/algo-did.algo.ts:108
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 0 8
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz skip_and0
	frame_dig -2 // boxIndex: uint64
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 8 8
	btoi
	<=
	&&

skip_and0:
	assert

	// if0_condition
	// contracts/algo-did.algo.ts:110
	// offset === 0
	frame_dig -3 // offset: uint64
	int 0
	==
	bz if0_end

	// if0_consequent
	// contracts/algo-did.algo.ts:111
	// this.dataBoxes(boxIndex).create(
	//         boxIndex === metadata.end ? metadata.endSize : MAX_BOX_SIZE,
	//       )
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -2 // boxIndex: uint64
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 8 8
	btoi
	==
	bz ternary0_false
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 17 8
	btoi
	b ternary0_end

ternary0_false:
	int 32768

ternary0_end:
	box_create

if0_end:
	// contracts/algo-did.algo.ts:116
	// this.dataBoxes(boxIndex).replace(offset, data)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -3 // offset: uint64
	frame_dig -4 // data: bytes
	box_replace
	retsub

// finishUpload(address)void
//
// 
// Mark uploading as false
// 
// @param pubKey The address of the DID
abi_route_finishUpload:
	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute finishUpload(address)void
	callsub finishUpload
	int 1
	return

finishUpload:
	proto 1 0

	// contracts/algo-did.algo.ts:126
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:128
	// this.metadata(pubKey).value.status = READY
	frame_dig -1 // pubKey: address
	int 16
	byte 0x01
	box_replace
	retsub

// startDelete(address)void
//
// Starts the deletion process for the data associated with a DID
// 
// @param pubKey The address of the DID
abi_route_startDelete:
	byte 0x // push empty bytes to fill the stack frame for this subroutine's local variables

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute startDelete(address)void
	callsub startDelete
	int 1
	return

startDelete:
	proto 2 0

	// contracts/algo-did.algo.ts:137
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:139
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: address
	frame_bury -2 // storage key//metadata

	// contracts/algo-did.algo.ts:140
	// assert(metadata.status === READY)
	frame_dig -2 // storage key//metadata
	box_get
	assert
	extract 16 1
	byte 0x0000000000000001
	b==
	assert

	// contracts/algo-did.algo.ts:142
	// metadata.status = DELETING
	frame_dig -2 // storage key//metadata
	box_get
	assert
	byte 0x02
	replace2 16
	frame_dig -2 // storage key//metadata
	swap
	box_put
	retsub

// deleteData(uint64,address)void
//
// Deletes a box of data
// 
// @param pubKey The address of the DID
// @param boxIndex The index of the box to delete
abi_route_deleteData:
	byte 0x; dup // push empty bytes to fill the stack frame for this subroutine's local variables

	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute deleteData(uint64,address)void
	callsub deleteData
	int 1
	return

deleteData:
	proto 4 0

	// contracts/algo-did.algo.ts:152
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:154
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: address
	frame_bury -3 // storage key//metadata

	// contracts/algo-did.algo.ts:155
	// assert(metadata.status === DELETING)
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 16 1
	byte 0x0000000000000002
	b==
	assert

	// contracts/algo-did.algo.ts:156
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 0 8
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz skip_and1
	frame_dig -2 // boxIndex: uint64
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 8 8
	btoi
	<=
	&&

skip_and1:
	assert

	// if1_condition
	// contracts/algo-did.algo.ts:158
	// boxIndex !== metadata.start
	frame_dig -2 // boxIndex: uint64
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 0 8
	btoi
	!=
	bz if1_end

	// if1_consequent
	// contracts/algo-did.algo.ts:159
	// assert(metadata.lastDeleted === boxIndex - 1)
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 25 8
	btoi
	frame_dig -2 // boxIndex: uint64
	int 1
	-
	==
	assert

if1_end:
	// contracts/algo-did.algo.ts:162
	// preMBR = globals.currentApplicationAddress.minBalance
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	assert
	frame_bury -4 // preMBR: uint64

	// contracts/algo-did.algo.ts:164
	// this.dataBoxes(boxIndex).delete()
	frame_dig -2 // boxIndex: uint64
	itob
	box_del

	// if2_condition
	// contracts/algo-did.algo.ts:166
	// boxIndex === metadata.end
	frame_dig -2 // boxIndex: uint64
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 8 8
	btoi
	==
	bz if2_else

	// if2_consequent
	// contracts/algo-did.algo.ts:166
	// this.metadata(pubKey).delete()
	frame_dig -1 // pubKey: address
	box_del
	b if2_end

if2_else:
	// contracts/algo-did.algo.ts:167
	// metadata.lastDeleted = boxIndex
	frame_dig -3 // storage key//metadata
	box_get
	assert
	frame_dig -2 // boxIndex: uint64
	itob
	replace2 25
	frame_dig -3 // storage key//metadata
	swap
	box_put

if2_end:
	// contracts/algo-did.algo.ts:169
	// sendPayment({
	//       amount: preMBR - globals.currentApplicationAddress.minBalance,
	//       receiver: this.txn.sender,
	//     })
	itxn_begin
	int pay
	itxn_field TypeEnum

	// contracts/algo-did.algo.ts:170
	// amount: preMBR - globals.currentApplicationAddress.minBalance
	frame_dig -4 // preMBR: uint64
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	assert
	-
	itxn_field Amount

	// contracts/algo-did.algo.ts:171
	// receiver: this.txn.sender
	txn Sender
	itxn_field Receiver

	// Fee field not set, defaulting to 0
	int 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// updateApplication()void
//
// Allow the contract to be updated by the creator
abi_route_updateApplication:
	// execute updateApplication()void
	callsub updateApplication
	int 1
	return

updateApplication:
	proto 0 0

	// contracts/algo-did.algo.ts:179
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert
	retsub

// dummy()void
//
// Dummy function to add extra box references for deleteData.
// Boxes are 32k, but a single app call can only include enough references to read/write 8k
// at a time. Thus when a box is deleted, we need to add additional dummy calls with box
// references to increase the total read/write budget to 32k.
abi_route_dummy:
	// execute dummy()void
	callsub dummy
	int 1
	return

dummy:
	proto 0 0
	retsub

abi_route_createApplication:
	int 1
	return

create_NoOp:
	method "createApplication()void"
	txna ApplicationArgs 0
	match abi_route_createApplication
	err

call_NoOp:
	method "startUpload(address,uint64,uint64,pay)void"
	method "upload(address,uint64,uint64,byte[])void"
	method "finishUpload(address)void"
	method "startDelete(address)void"
	method "deleteData(address,uint64)void"
	method "dummy()void"
	txna ApplicationArgs 0
	match abi_route_startUpload abi_route_upload abi_route_finishUpload abi_route_startDelete abi_route_deleteData abi_route_dummy
	err

call_UpdateApplication:
	method "updateApplication()void"
	txna ApplicationArgs 0
	match abi_route_updateApplication
	err", + "approval": "#pragma version 9

// This TEAL was generated by TEALScript v0.51.1
// https://github.com/algorand-devrel/TEALScript

// This contract is compliant with and/or implements the following ARCs: [ ARC4 ]

// The following ten lines of TEAL handle initial program flow
// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed
// Here, action refers to the OnComplete in combination with whether the app is being created or called
// Every possible action for this contract is represented in the switch statement
// If the action is not implmented in the contract, its repsective branch will be "NOT_IMPLMENTED" which just contains "err"
txn ApplicationID
int 0
>
int 6
*
txn OnCompletion
+
switch create_NoOp NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED call_NoOp NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED call_UpdateApplication

NOT_IMPLEMENTED:
	err

// startUpload(pay,uint64,uint64,address)void
//
// 
// Allocate boxes to begin data upload process
// 
// @param pubKey The pubkey of the DID
// @param numBoxes The number of boxes that the data will take up
// @param endBoxSize The size of the last box
// @param mbrPayment Payment from the uploader to cover the box MBR
abi_route_startUpload:
	byte 0x; dupn 3 // push empty bytes to fill the stack frame for this subroutine's local variables

	// mbrPayment: pay
	txn GroupIndex
	int 1
	-
	dup
	gtxns TypeEnum
	int pay
	==
	assert

	// endBoxSize: uint64
	txna ApplicationArgs 3
	btoi

	// numBoxes: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute startUpload(pay,uint64,uint64,address)void
	callsub startUpload
	int 1
	return

startUpload:
	proto 8 0

	// contracts/algo-did.algo.ts:64
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:66
	// startBox = this.currentIndex.value
	byte 0x63757272656e74496e646578 // "currentIndex"
	app_global_get
	frame_bury -5 // startBox: uint64

	// contracts/algo-did.algo.ts:67
	// endBox = startBox + numBoxes - 1
	frame_dig -5 // startBox: uint64
	frame_dig -2 // numBoxes: uint64
	+
	int 1
	-
	frame_bury -6 // endBox: uint64

	// contracts/algo-did.algo.ts:69
	// metadata: Metadata = {
	//       start: startBox, end: endBox, status: UPLOADING, endSize: endBoxSize, lastDeleted: 0,
	//     }
	frame_dig -5 // startBox: uint64
	itob
	frame_dig -6 // endBox: uint64
	itob
	concat
	byte 0x00
	byte 0x00
	bitlen
	int 8
	<=
	assert
	byte 0xFF
	b&
	concat
	frame_dig -3 // endBoxSize: uint64
	itob
	concat
	byte 0x0000000000000000
	concat
	frame_bury -7 // metadata: Metadata

	// contracts/algo-did.algo.ts:73
	// assert(!this.metadata(pubKey).exists)
	frame_dig -1 // pubKey: address
	box_len
	swap
	pop
	!
	assert

	// contracts/algo-did.algo.ts:75
	// this.metadata(pubKey).value = metadata
	frame_dig -1 // pubKey: address
	frame_dig -7 // metadata: Metadata
	box_put

	// contracts/algo-did.algo.ts:77
	// this.currentIndex.value = endBox + 1
	byte 0x63757272656e74496e646578 // "currentIndex"
	frame_dig -6 // endBox: uint64
	int 1
	+
	app_global_put

	// contracts/algo-did.algo.ts:79
	// totalCost = numBoxes * COST_PER_BOX // cost of data boxes
	//     + (numBoxes - 1) * MAX_BOX_SIZE * COST_PER_BYTE // cost of data
	//     + numBoxes * 8 * COST_PER_BYTE // cost of data keys
	//     + endBoxSize * COST_PER_BYTE // cost of last data box
	//     + COST_PER_BOX + (8 + 8 + 1 + 8 + 32 + 8) * COST_PER_BYTE
	frame_dig -2 // numBoxes: uint64
	int 2500
	*
	frame_dig -2 // numBoxes: uint64
	int 1
	-
	int 32768
	*
	int 400
	*
	+
	frame_dig -2 // numBoxes: uint64
	int 8
	*
	int 400
	*
	+
	frame_dig -3 // endBoxSize: uint64
	int 400
	*
	+
	int 2500
	+
	int 26000
	+
	frame_bury -8 // totalCost: uint64

	// contracts/algo-did.algo.ts:85
	// assert(mbrPayment.amount === totalCost)
	frame_dig -4 // mbrPayment: pay
	gtxns Amount
	frame_dig -8 // totalCost: uint64
	==
	assert

	// contracts/algo-did.algo.ts:86
	// assert(mbrPayment.receiver === this.app.address)
	frame_dig -4 // mbrPayment: pay
	gtxns Receiver
	global CurrentApplicationAddress
	==
	assert
	retsub

// upload(bytes,uint64,uint64,address)void
//
// 
// Upload data to a specific offset in a box
// 
// @param pubKey The pubkey of the DID
// @param boxIndex The index of the box to upload the given chunk of data to
// @param offset The offset within the box to start writing the data
// @param data The data to write
abi_route_upload:
	byte 0x // push empty bytes to fill the stack frame for this subroutine's local variables

	// data: byte[]
	txna ApplicationArgs 4
	extract 2 0

	// offset: uint64
	txna ApplicationArgs 3
	btoi

	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute upload(bytes,uint64,uint64,address)void
	callsub upload
	int 1
	return

upload:
	proto 5 0

	// contracts/algo-did.algo.ts:99
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:101
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: address
	frame_bury -5 // storage key//metadata

	// contracts/algo-did.algo.ts:102
	// assert(metadata.status === UPLOADING)
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 16 1
	byte 0x0000000000000000
	b==
	assert

	// contracts/algo-did.algo.ts:103
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 0 8
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz skip_and0
	frame_dig -2 // boxIndex: uint64
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 8 8
	btoi
	<=
	&&

skip_and0:
	assert

	// if0_condition
	// contracts/algo-did.algo.ts:105
	// offset === 0
	frame_dig -3 // offset: uint64
	int 0
	==
	bz if0_end

	// if0_consequent
	// contracts/algo-did.algo.ts:106
	// this.dataBoxes(boxIndex).create(boxIndex === metadata.end ? metadata.endSize : MAX_BOX_SIZE)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -2 // boxIndex: uint64
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 8 8
	btoi
	==
	bz ternary0_false
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 17 8
	btoi
	b ternary0_end

ternary0_false:
	int 32768

ternary0_end:
	box_create

if0_end:
	// contracts/algo-did.algo.ts:109
	// this.dataBoxes(boxIndex).replace(offset, data)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -3 // offset: uint64
	frame_dig -4 // data: bytes
	box_replace
	retsub

// finishUpload(address)void
//
// 
// Mark uploading as false
// 
// @param pubKey The address of the DID
abi_route_finishUpload:
	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute finishUpload(address)void
	callsub finishUpload
	int 1
	return

finishUpload:
	proto 1 0

	// contracts/algo-did.algo.ts:119
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:121
	// this.metadata(pubKey).value.status = READY
	frame_dig -1 // pubKey: address
	int 16
	byte 0x01
	box_replace
	retsub

// startDelete(address)void
//
// Starts the deletion process for the data associated with a DID
// 
// @param pubKey The address of the DID
abi_route_startDelete:
	byte 0x // push empty bytes to fill the stack frame for this subroutine's local variables

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute startDelete(address)void
	callsub startDelete
	int 1
	return

startDelete:
	proto 2 0

	// contracts/algo-did.algo.ts:130
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:132
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: address
	frame_bury -2 // storage key//metadata

	// contracts/algo-did.algo.ts:133
	// assert(metadata.status === READY)
	frame_dig -2 // storage key//metadata
	box_get
	assert
	extract 16 1
	byte 0x0000000000000001
	b==
	assert

	// contracts/algo-did.algo.ts:135
	// metadata.status = DELETING
	frame_dig -2 // storage key//metadata
	box_get
	assert
	byte 0x02
	replace2 16
	frame_dig -2 // storage key//metadata
	swap
	box_put
	retsub

// deleteData(uint64,address)void
//
// Deletes a box of data
// 
// @param pubKey The address of the DID
// @param boxIndex The index of the box to delete
abi_route_deleteData:
	byte 0x; dup // push empty bytes to fill the stack frame for this subroutine's local variables

	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute deleteData(uint64,address)void
	callsub deleteData
	int 1
	return

deleteData:
	proto 4 0

	// contracts/algo-did.algo.ts:145
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:147
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: address
	frame_bury -3 // storage key//metadata

	// contracts/algo-did.algo.ts:148
	// assert(metadata.status === DELETING)
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 16 1
	byte 0x0000000000000002
	b==
	assert

	// contracts/algo-did.algo.ts:149
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 0 8
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz skip_and1
	frame_dig -2 // boxIndex: uint64
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 8 8
	btoi
	<=
	&&

skip_and1:
	assert

	// if1_condition
	// contracts/algo-did.algo.ts:151
	// boxIndex !== metadata.start
	frame_dig -2 // boxIndex: uint64
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 0 8
	btoi
	!=
	bz if1_end

	// if1_consequent
	// contracts/algo-did.algo.ts:151
	// assert(metadata.lastDeleted === boxIndex - 1)
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 25 8
	btoi
	frame_dig -2 // boxIndex: uint64
	int 1
	-
	==
	assert

if1_end:
	// contracts/algo-did.algo.ts:153
	// preMBR = globals.currentApplicationAddress.minBalance
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	assert
	frame_bury -4 // preMBR: uint64

	// contracts/algo-did.algo.ts:155
	// this.dataBoxes(boxIndex).delete()
	frame_dig -2 // boxIndex: uint64
	itob
	box_del

	// if2_condition
	// contracts/algo-did.algo.ts:157
	// boxIndex === metadata.end
	frame_dig -2 // boxIndex: uint64
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 8 8
	btoi
	==
	bz if2_else

	// if2_consequent
	// contracts/algo-did.algo.ts:157
	// this.metadata(pubKey).delete()
	frame_dig -1 // pubKey: address
	box_del
	b if2_end

if2_else:
	// contracts/algo-did.algo.ts:158
	// metadata.lastDeleted = boxIndex
	frame_dig -3 // storage key//metadata
	box_get
	assert
	frame_dig -2 // boxIndex: uint64
	itob
	replace2 25
	frame_dig -3 // storage key//metadata
	swap
	box_put

if2_end:
	// contracts/algo-did.algo.ts:160
	// sendPayment({
	//       amount: preMBR - globals.currentApplicationAddress.minBalance,
	//       receiver: this.txn.sender,
	//     })
	itxn_begin
	int pay
	itxn_field TypeEnum

	// contracts/algo-did.algo.ts:161
	// amount: preMBR - globals.currentApplicationAddress.minBalance
	frame_dig -4 // preMBR: uint64
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	assert
	-
	itxn_field Amount

	// contracts/algo-did.algo.ts:162
	// receiver: this.txn.sender
	txn Sender
	itxn_field Receiver

	// Fee field not set, defaulting to 0
	int 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// updateApplication()void
//
// Allow the contract to be updated by the creator
abi_route_updateApplication:
	// execute updateApplication()void
	callsub updateApplication
	int 1
	return

updateApplication:
	proto 0 0

	// contracts/algo-did.algo.ts:170
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert
	retsub

// dummy()void
//
// Dummy function to add extra box references for deleteData.
// Boxes are 32k, but a single app call can only inlcude enough references to read/write 8k
// at a time. Thus when a box is deleted, we need to add additional dummy calls with box
// references to increase the total read/write budget to 32k.
abi_route_dummy:
	// execute dummy()void
	callsub dummy
	int 1
	return

dummy:
	proto 0 0
	retsub

abi_route_createApplication:
	int 1
	return

create_NoOp:
	method "createApplication()void"
	txna ApplicationArgs 0
	match abi_route_createApplication
	err

call_NoOp:
	method "startUpload(address,uint64,uint64,pay)void"
	method "upload(address,uint64,uint64,byte[])void"
	method "finishUpload(address)void"
	method "startDelete(address)void"
	method "deleteData(address,uint64)void"
	method "dummy()void"
	txna ApplicationArgs 0
	match abi_route_startUpload abi_route_upload abi_route_finishUpload abi_route_startDelete abi_route_deleteData abi_route_dummy
	err

call_UpdateApplication:
	method "updateApplication()void"
	txna ApplicationArgs 0
	match abi_route_updateApplication
	err", "clear": "I3ByYWdtYSB2ZXJzaW9uIDkKaW50IDE=" }, "contract": { @@ -203,7 +203,7 @@ { "name": "dummy", "args": [], - "desc": "Dummy function to add extra box references for deleteData.Boxes are 32k, but a single app call can only include enough references to read/write 8kat a time. Thus when a box is deleted, we need to add additional dummy calls with boxreferences to increase the total read/write budget to 32k.", + "desc": "Dummy function to add extra box references for deleteData.Boxes are 32k, but a single app call can only inlcude enough references to read/write 8kat a time. Thus when a box is deleted, we need to add additional dummy calls with boxreferences to increase the total read/write budget to 32k.", "returns": { "type": "void", "desc": "" diff --git a/client/internal/contracts/AlgoDID.src_map.json b/client/internal/contracts/AlgoDID.src_map.json index f5badef..8128601 100644 --- a/client/internal/contracts/AlgoDID.src_map.json +++ b/client/internal/contracts/AlgoDID.src_map.json @@ -1,5784 +1,2936 @@ [ { "teal": 1, - "source": { - "start": { - "line": 39, - "col": 0 - }, - "end": { - "line": 189, - "col": 1 - } - }, - "pc": 0 - }, - { - "teal": 2, - "source": { - "start": { - "line": 39, - "col": 0 - }, - "end": { - "line": 189, - "col": 1 - } - }, - "pc": 0 - }, - { - "teal": 5, - "source": { - "start": { - "line": 39, - "col": 0 - }, - "end": { - "line": 189, - "col": 1 - } - }, - "pc": 0 - }, - { - "teal": 7, - "source": { - "start": { - "line": 39, - "col": 0 - }, - "end": { - "line": 189, - "col": 1 - } - }, - "pc": 0 + "source": 38, + "pc": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31 + ] }, { "teal": 13, - "source": { - "start": { - "line": 39, - "col": 0 - }, - "end": { - "line": 189, - "col": 1 - } - }, - "pc": 0 + "source": 38, + "pc": [ + 32, + 33 + ] }, { "teal": 14, - "source": { - "start": { - "line": 39, - "col": 0 - }, - "end": { - "line": 189, - "col": 1 - } - }, - "pc": 0 + "source": 38, + "pc": [ + 34 + ] }, { "teal": 15, - "source": { - "start": { - "line": 39, - "col": 0 - }, - "end": { - "line": 189, - "col": 1 - } - }, - "pc": 0 + "source": 38, + "pc": [ + 35, + 36 + ] }, { "teal": 16, - "source": { - "start": { - "line": 39, - "col": 0 - }, - "end": { - "line": 189, - "col": 1 - } - }, - "pc": 0 + "source": 38, + "pc": [ + 37 + ] }, { "teal": 17, - "source": { - "start": { - "line": 39, - "col": 0 - }, - "end": { - "line": 189, - "col": 1 - } - }, - "pc": 0 + "source": 38, + "pc": [ + 38, + 39 + ] }, { "teal": 18, - "source": { - "start": { - "line": 39, - "col": 0 - }, - "end": { - "line": 189, - "col": 1 - } - }, - "pc": 0 + "source": 38, + "pc": [ + 40 + ] }, { "teal": 19, - "source": { - "start": { - "line": 39, - "col": 0 - }, - "end": { - "line": 189, - "col": 1 - } - }, - "pc": 0 - }, - { - "teal": 20, - "source": { - "start": { - "line": 39, - "col": 0 - }, - "end": { - "line": 189, - "col": 1 - } - }, - "pc": 0 - }, - { - "teal": 22, - "source": { - "start": { - "line": 39, - "col": 0 - }, - "end": { - "line": 189, - "col": 1 - } - }, - "pc": 0 + "source": 38, + "pc": [ + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66 + ] }, { "teal": 23, - "source": { - "start": { - "line": 39, - "col": 0 - }, - "end": { - "line": 189, - "col": 1 - } - }, - "pc": 0 + "source": 38, + "errorMessage": "The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?", + "pc": [ + 67 + ] + }, + { + "teal": 28, + "source": 61, + "pc": [ + 68, + 69 + ] + }, + { + "teal": 29, + "source": 61, + "pc": [ + 70 + ] + }, + { + "teal": 30, + "source": 61, + "pc": [ + 71 + ] + }, + { + "teal": 31, + "source": 61, + "pc": [ + 72 + ] + }, + { + "teal": 32, + "source": 61, + "pc": [ + 73, + 74 + ] + }, + { + "teal": 33, + "source": 61, + "pc": [ + 75 + ] }, { "teal": 34, - "source": { - "start": { - "line": 58, - "col": 2 - }, - "end": { - "line": 92, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 35, - "source": { - "start": { - "line": 58, - "col": 2 - }, - "end": { - "line": 92, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 38, - "source": { - "start": { - "line": 62, - "col": 4 - }, - "end": { - "line": 62, - "col": 22 - } - }, - "pc": 0 - }, - { - "teal": 39, - "source": { - "start": { - "line": 62, - "col": 4 - }, - "end": { - "line": 62, - "col": 22 - } - }, - "pc": 0 + "source": 61, + "pc": [ + 76 + ] + }, + { + "teal": 37, + "source": 61, + "errorMessage": "argument 0 (mbrPayment) for startUpload must be a pay transaction", + "pc": [ + 77 + ] }, { "teal": 40, - "source": { - "start": { - "line": 62, - "col": 4 - }, - "end": { - "line": 62, - "col": 22 - } - }, - "pc": 0 + "source": 60, + "pc": [ + 78, + 79, + 80 + ] }, { "teal": 41, - "source": { - "start": { - "line": 62, - "col": 4 - }, - "end": { - "line": 62, - "col": 22 - } - }, - "pc": 0 - }, - { - "teal": 42, - "source": { - "start": { - "line": 62, - "col": 4 - }, - "end": { - "line": 62, - "col": 22 - } - }, - "pc": 0 - }, - { - "teal": 43, - "source": { - "start": { - "line": 62, - "col": 4 - }, - "end": { - "line": 62, - "col": 22 - } - }, - "pc": 0 + "source": 60, + "pc": [ + 81 + ] }, { "teal": 44, - "source": { - "start": { - "line": 62, - "col": 4 - }, - "end": { - "line": 62, - "col": 22 - } - }, - "pc": 0 + "source": 59, + "pc": [ + 82, + 83, + 84 + ] }, { "teal": 45, - "source": { - "start": { - "line": 62, - "col": 4 - }, - "end": { - "line": 62, - "col": 22 - } - }, - "pc": 0 + "source": 59, + "pc": [ + 85 + ] }, { "teal": 48, - "source": { - "start": { - "line": 61, - "col": 4 - }, - "end": { - "line": 61, - "col": 22 - } - }, - "pc": 0 + "source": 58, + "pc": [ + 86, + 87, + 88 + ] }, { "teal": 49, - "source": { - "start": { - "line": 61, - "col": 4 - }, - "end": { - "line": 61, - "col": 22 - } - }, - "pc": 0 + "source": 58, + "pc": [ + 89 + ] + }, + { + "teal": 50, + "source": 58, + "pc": [ + 90 + ] + }, + { + "teal": 51, + "source": 58, + "pc": [ + 91 + ] }, { "teal": 52, - "source": { - "start": { - "line": 60, - "col": 4 - }, - "end": { - "line": 60, - "col": 20 - } - }, - "pc": 0 - }, - { - "teal": 53, - "source": { - "start": { - "line": 60, - "col": 4 - }, - "end": { - "line": 60, - "col": 20 - } - }, - "pc": 0 - }, - { - "teal": 56, - "source": { - "start": { - "line": 59, - "col": 4 - }, - "end": { - "line": 59, - "col": 19 - } - }, - "pc": 0 - }, - { - "teal": 57, - "source": { - "start": { - "line": 59, - "col": 4 - }, - "end": { - "line": 59, - "col": 19 - } - }, - "pc": 0 + "source": 58, + "pc": [ + 92 + ] + }, + { + "teal": 55, + "source": 58, + "errorMessage": "argument 3 (pubKey) for startUpload must be a address", + "pc": [ + 93 + ] }, { "teal": 58, - "source": { - "start": { - "line": 59, - "col": 4 - }, - "end": { - "line": 59, - "col": 19 - } - }, - "pc": 0 + "source": 57, + "pc": [ + 94, + 95, + 96 + ] }, { "teal": 59, - "source": { - "start": { - "line": 59, - "col": 4 - }, - "end": { - "line": 59, - "col": 19 - } - }, - "pc": 0 + "source": 57, + "pc": [ + 97 + ] }, { "teal": 60, - "source": { - "start": { - "line": 59, - "col": 4 - }, - "end": { - "line": 59, - "col": 19 - } - }, - "pc": 0 - }, - { - "teal": 61, - "source": { - "start": { - "line": 59, - "col": 4 - }, - "end": { - "line": 59, - "col": 19 - } - }, - "pc": 0 - }, - { - "teal": 64, - "source": { - "start": { - "line": 58, - "col": 2 - }, - "end": { - "line": 92, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 65, - "source": { - "start": { - "line": 58, - "col": 2 - }, - "end": { - "line": 92, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 66, - "source": { - "start": { - "line": 58, - "col": 2 - }, - "end": { - "line": 92, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 68, - "source": { - "start": { - "line": 58, - "col": 2 - }, - "end": { - "line": 92, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 69, - "source": { - "start": { - "line": 58, - "col": 2 - }, - "end": { - "line": 92, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 73, - "source": { - "start": { - "line": 64, - "col": 11 - }, - "end": { - "line": 64, - "col": 19 - } - }, - "pc": 0 - }, - { - "teal": 74, - "source": { - "start": { - "line": 64, - "col": 31 - }, - "end": { - "line": 64, - "col": 53 - } - }, - "pc": 0 + "source": 57, + "pc": [ + 98 + ] + }, + { + "teal": 72, + "source": 57, + "pc": [ + 99, + 100, + 101 + ] }, { "teal": 75, - "source": { - "start": { - "line": 64, - "col": 27 - }, - "end": { - "line": 64, - "col": 30 - } - }, - "pc": 0 + "source": 57, + "pc": [ + 102 + ] }, { "teal": 76, - "source": { - "start": { - "line": 64, - "col": 11 - }, - "end": { - "line": 64, - "col": 53 - } - }, - "pc": 0 + "source": 57, + "pc": [ + 103, + 104 + ] }, { "teal": 80, - "source": { - "start": { - "line": 66, - "col": 21 - }, - "end": { - "line": 66, - "col": 38 - } - }, - "pc": 0 + "source": 63, + "pc": [ + 105, + 106 + ] }, { "teal": 81, - "source": { - "start": { - "line": 66, - "col": 21 - }, - "end": { - "line": 66, - "col": 38 - } - }, - "pc": 0 + "source": 63, + "pc": [ + 107, + 108 + ] }, { "teal": 82, - "source": { - "start": { - "line": 66, - "col": 10 - }, - "end": { - "line": 66, - "col": 44 - } - }, - "pc": 0 - }, - { - "teal": 86, - "source": { - "start": { - "line": 67, - "col": 28 - }, - "end": { - "line": 67, - "col": 29 - } - }, - "pc": 0 + "source": 63, + "pc": [ + 109 + ] + }, + { + "teal": 83, + "source": 63, + "pc": [ + 110 + ] }, { "teal": 87, - "source": { - "start": { - "line": 67, - "col": 41 - }, - "end": { - "line": 67, - "col": 42 - } - }, - "pc": 0 + "source": 65, + "pc": [ + 111 + ] }, { "teal": 88, - "source": { - "start": { - "line": 67, - "col": 39 - }, - "end": { - "line": 67, - "col": 40 - } - }, - "pc": 0 + "source": 65, + "pc": [ + 112 + ] }, { "teal": 89, - "source": { - "start": { - "line": 67, - "col": 41 - }, - "end": { - "line": 67, - "col": 42 - } - }, - "pc": 0 - }, - { - "teal": 90, - "source": { - "start": { - "line": 67, - "col": 39 - }, - "end": { - "line": 67, - "col": 40 - } - }, - "pc": 0 - }, - { - "teal": 91, - "source": { - "start": { - "line": 67, - "col": 10 - }, - "end": { - "line": 67, - "col": 42 - } - }, - "pc": 0 - }, - { - "teal": 101, - "source": { - "start": { - "line": 70, - "col": 13 - }, - "end": { - "line": 70, - "col": 21 - } - }, - "pc": 0 - }, - { - "teal": 102, - "source": { - "start": { - "line": 70, - "col": 13 - }, - "end": { - "line": 70, - "col": 21 - } - }, - "pc": 0 - }, - { - "teal": 103, - "source": { - "start": { - "line": 71, - "col": 11 - }, - "end": { - "line": 71, - "col": 17 - } - }, - "pc": 0 + "source": 65, + "pc": [ + 113, + 114 + ] + }, + { + "teal": 93, + "source": 66, + "pc": [ + 115, + 116 + ] + }, + { + "teal": 94, + "source": 66, + "pc": [ + 117, + 118 + ] + }, + { + "teal": 95, + "source": 66, + "pc": [ + 119 + ] + }, + { + "teal": 96, + "source": 66, + "pc": [ + 120 + ] + }, + { + "teal": 97, + "source": 66, + "pc": [ + 121 + ] + }, + { + "teal": 98, + "source": 66, + "pc": [ + 122, + 123 + ] }, { "teal": 104, - "source": { - "start": { - "line": 71, - "col": 11 - }, - "end": { - "line": 71, - "col": 17 - } - }, - "pc": 0 + "source": 69, + "pc": [ + 124, + 125 + ] }, { "teal": 105, - "source": { - "start": { - "line": 69, - "col": 31 - }, - "end": { - "line": 75, - "col": 5 - } - }, - "pc": 0 + "source": 69, + "pc": [ + 126 + ] }, { "teal": 106, - "source": { - "start": { - "line": 26, - "col": 27 - }, - "end": { - "line": 26, - "col": 28 - } - }, - "pc": 0 + "source": 69, + "pc": [ + 127, + 128 + ] }, { "teal": 107, - "source": { - "start": { - "line": 72, - "col": 14 - }, - "end": { - "line": 72, - "col": 23 - } - }, - "pc": 0 + "source": 69, + "pc": [ + 129 + ] }, { "teal": 108, - "source": { - "start": { - "line": 72, - "col": 14 - }, - "end": { - "line": 72, - "col": 23 - } - }, - "pc": 0 + "source": 69, + "pc": [ + 130 + ] }, { "teal": 109, - "source": { - "start": { - "line": 72, - "col": 14 - }, - "end": { - "line": 72, - "col": 23 - } - }, - "pc": 0 + "source": 69, + "pc": [ + 131, + 132, + 133 + ] }, { "teal": 110, - "source": { - "start": { - "line": 72, - "col": 14 - }, - "end": { - "line": 72, - "col": 23 - } - }, - "pc": 0 + "source": 69, + "pc": [ + 134 + ] }, { "teal": 111, - "source": { - "start": { - "line": 72, - "col": 14 - }, - "end": { - "line": 72, - "col": 23 - } - }, - "pc": 0 + "source": 69, + "pc": [ + 135, + 136 + ] }, { "teal": 112, - "source": { - "start": { - "line": 72, - "col": 14 - }, - "end": { - "line": 72, - "col": 23 - } - }, - "pc": 0 + "source": 69, + "pc": [ + 137 + ] }, { "teal": 113, - "source": { - "start": { - "line": 72, - "col": 14 - }, - "end": { - "line": 72, - "col": 23 - } - }, - "pc": 0 + "source": 69, + "pc": [ + 138 + ] }, { "teal": 114, - "source": { - "start": { - "line": 69, - "col": 31 - }, - "end": { - "line": 75, - "col": 5 - } - }, - "pc": 0 + "source": 69, + "pc": [ + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148 + ] }, { "teal": 115, - "source": { - "start": { - "line": 73, - "col": 15 - }, - "end": { - "line": 73, - "col": 25 - } - }, - "pc": 0 + "source": 69, + "pc": [ + 149 + ] }, { "teal": 116, - "source": { - "start": { - "line": 73, - "col": 15 - }, - "end": { - "line": 73, - "col": 25 - } - }, - "pc": 0 - }, - { - "teal": 117, - "source": { - "start": { - "line": 69, - "col": 31 - }, - "end": { - "line": 75, - "col": 5 - } - }, - "pc": 0 - }, - { - "teal": 118, - "source": { - "start": { - "line": 74, - "col": 19 - }, - "end": { - "line": 74, - "col": 20 - } - }, - "pc": 0 - }, - { - "teal": 119, - "source": { - "start": { - "line": 74, - "col": 19 - }, - "end": { - "line": 74, - "col": 20 - } - }, - "pc": 0 + "source": 68, + "pc": [ + 150, + 151 + ] }, { "teal": 120, - "source": { - "start": { - "line": 69, - "col": 31 - }, - "end": { - "line": 75, - "col": 5 - } - }, - "pc": 0 + "source": 72, + "pc": [ + 152, + 153 + ] + }, + { + "teal": 121, + "source": 72, + "pc": [ + 154 + ] + }, + { + "teal": 122, + "source": 72, + "pc": [ + 155 + ] + }, + { + "teal": 123, + "source": 72, + "pc": [ + 156 + ] }, { "teal": 124, - "source": { - "start": { - "line": 77, - "col": 4 - }, - "end": { - "line": 77, - "col": 41 - } - }, - "pc": 0 + "source": 72, + "pc": [ + 157 + ] }, { "teal": 125, - "source": { - "start": { - "line": 77, - "col": 26 - }, - "end": { - "line": 77, - "col": 32 - } - }, - "pc": 0 - }, - { - "teal": 126, - "source": { - "start": { - "line": 77, - "col": 12 - }, - "end": { - "line": 77, - "col": 33 - } - }, - "pc": 0 - }, - { - "teal": 127, - "source": { - "start": { - "line": 77, - "col": 12 - }, - "end": { - "line": 77, - "col": 33 - } - }, - "pc": 0 - }, - { - "teal": 128, - "source": { - "start": { - "line": 77, - "col": 12 - }, - "end": { - "line": 77, - "col": 33 - } - }, - "pc": 0 + "source": 72, + "pc": [ + 158 + ] }, { "teal": 129, - "source": { - "start": { - "line": 77, - "col": 12 - }, - "end": { - "line": 77, - "col": 40 - } - }, - "pc": 0 - }, - { - "teal": 133, - "source": { - "start": { - "line": 79, - "col": 4 - }, - "end": { - "line": 79, - "col": 42 - } - }, - "pc": 0 - }, - { - "teal": 134, - "source": { - "start": { - "line": 79, - "col": 18 - }, - "end": { - "line": 79, - "col": 24 - } - }, - "pc": 0 + "source": 74, + "pc": [ + 159, + 160 + ] + }, + { + "teal": 130, + "source": 74, + "pc": [ + 161, + 162 + ] + }, + { + "teal": 131, + "source": 74, + "pc": [ + 163 + ] }, { "teal": 135, - "source": { - "start": { - "line": 79, - "col": 4 - }, - "end": { - "line": 79, - "col": 25 - } - }, - "pc": 0 + "source": 76, + "pc": [ + 164 + ] + }, + { + "teal": 136, + "source": 76, + "pc": [ + 165, + 166 + ] + }, + { + "teal": 137, + "source": 76, + "pc": [ + 167 + ] + }, + { + "teal": 138, + "source": 76, + "pc": [ + 168 + ] }, { "teal": 139, - "source": { - "start": { - "line": 81, - "col": 4 - }, - "end": { - "line": 81, - "col": 40 - } - }, - "pc": 0 - }, - { - "teal": 140, - "source": { - "start": { - "line": 81, - "col": 4 - }, - "end": { - "line": 81, - "col": 21 - } - }, - "pc": 0 - }, - { - "teal": 141, - "source": { - "start": { - "line": 81, - "col": 4 - }, - "end": { - "line": 81, - "col": 21 - } - }, - "pc": 0 - }, - { - "teal": 142, - "source": { - "start": { - "line": 81, - "col": 39 - }, - "end": { - "line": 81, - "col": 40 - } - }, - "pc": 0 - }, - { - "teal": 143, - "source": { - "start": { - "line": 81, - "col": 37 - }, - "end": { - "line": 81, - "col": 38 - } - }, - "pc": 0 + "source": 76, + "pc": [ + 169 + ] + }, + { + "teal": 147, + "source": 78, + "pc": [ + 170, + 171 + ] + }, + { + "teal": 148, + "source": 78, + "pc": [ + 172, + 173 + ] + }, + { + "teal": 149, + "source": 78, + "pc": [ + 174 + ] + }, + { + "teal": 150, + "source": 79, + "pc": [ + 175, + 176 + ] + }, + { + "teal": 151, + "source": 79, + "pc": [ + 177 + ] }, { "teal": 152, - "source": { - "start": { - "line": 36, - "col": 21 - }, - "end": { - "line": 36, - "col": 26 - } - }, - "pc": 0 + "source": 79, + "pc": [ + 178 + ] }, { "teal": 153, - "source": { - "start": { - "line": 84, - "col": 21 - }, - "end": { - "line": 84, - "col": 22 - } - }, - "pc": 0 + "source": 79, + "pc": [ + 179, + 180 + ] }, { "teal": 154, - "source": { - "start": { - "line": 34, - "col": 22 - }, - "end": { - "line": 34, - "col": 25 - } - }, - "pc": 0 + "source": 79, + "pc": [ + 181 + ] }, { "teal": 155, - "source": { - "start": { - "line": 84, - "col": 36 - }, - "end": { - "line": 84, - "col": 37 - } - }, - "pc": 0 + "source": 79, + "pc": [ + 182, + 183 + ] }, { "teal": 156, - "source": { - "start": { - "line": 83, - "col": 46 - }, - "end": { - "line": 83, - "col": 47 - } - }, - "pc": 0 + "source": 79, + "pc": [ + 184 + ] }, { "teal": 157, - "source": { - "start": { - "line": 85, - "col": 6 - }, - "end": { - "line": 85, - "col": 14 - } - }, - "pc": 0 + "source": 79, + "pc": [ + 185 + ] }, { "teal": 158, - "source": { - "start": { - "line": 85, - "col": 17 - }, - "end": { - "line": 85, - "col": 18 - } - }, - "pc": 0 + "source": 80, + "pc": [ + 186, + 187 + ] }, { "teal": 159, - "source": { - "start": { - "line": 85, - "col": 15 - }, - "end": { - "line": 85, - "col": 16 - } - }, - "pc": 0 + "source": 80, + "pc": [ + 188 + ] }, { "teal": 160, - "source": { - "start": { - "line": 34, - "col": 22 - }, - "end": { - "line": 34, - "col": 25 - } - }, - "pc": 0 + "source": 80, + "pc": [ + 189 + ] }, { "teal": 161, - "source": { - "start": { - "line": 85, - "col": 19 - }, - "end": { - "line": 85, - "col": 20 - } - }, - "pc": 0 + "source": 80, + "pc": [ + 190, + 191 + ] }, { "teal": 162, - "source": { - "start": { - "line": 84, - "col": 52 - }, - "end": { - "line": 84, - "col": 53 - } - }, - "pc": 0 + "source": 80, + "pc": [ + 192 + ] }, { "teal": 163, - "source": { - "start": { - "line": 86, - "col": 6 - }, - "end": { - "line": 86, - "col": 16 - } - }, - "pc": 0 + "source": 80, + "pc": [ + 193 + ] }, { "teal": 164, - "source": { - "start": { - "line": 34, - "col": 22 - }, - "end": { - "line": 34, - "col": 25 - } - }, - "pc": 0 + "source": 81, + "pc": [ + 194, + 195 + ] }, { "teal": 165, - "source": { - "start": { - "line": 86, - "col": 17 - }, - "end": { - "line": 86, - "col": 18 - } - }, - "pc": 0 + "source": 81, + "pc": [ + 196, + 197 + ] }, { "teal": 166, - "source": { - "start": { - "line": 85, - "col": 35 - }, - "end": { - "line": 85, - "col": 36 - } - }, - "pc": 0 + "source": 81, + "pc": [ + 198 + ] }, { "teal": 167, - "source": { - "start": { - "line": 35, - "col": 21 - }, - "end": { - "line": 35, - "col": 25 - } - }, - "pc": 0 + "source": 81, + "pc": [ + 199 + ] }, { "teal": 168, - "source": { - "start": { - "line": 86, - "col": 33 - }, - "end": { - "line": 86, - "col": 34 - } - }, - "pc": 0 + "source": 82, + "pc": [ + 200, + 201 + ] }, { "teal": 169, - "source": { - "start": { - "line": 88, - "col": 7 - }, - "end": { - "line": 88, - "col": 8 - } - }, - "pc": 0 + "source": 82, + "pc": [ + 202 + ] }, { "teal": 170, - "source": { - "start": { - "line": 88, - "col": 11 - }, - "end": { - "line": 88, - "col": 12 - } - }, - "pc": 0 + "source": 82, + "pc": [ + 203, + 204, + 205, + 206 + ] }, { "teal": 171, - "source": { - "start": { - "line": 88, - "col": 9 - }, - "end": { - "line": 88, - "col": 10 - } - }, - "pc": 0 + "source": 82, + "pc": [ + 207 + ] }, { "teal": 172, - "source": { - "start": { - "line": 88, - "col": 15 - }, - "end": { - "line": 88, - "col": 16 - } - }, - "pc": 0 - }, - { - "teal": 173, - "source": { - "start": { - "line": 88, - "col": 13 - }, - "end": { - "line": 88, - "col": 14 - } - }, - "pc": 0 - }, - { - "teal": 174, - "source": { - "start": { - "line": 88, - "col": 19 - }, - "end": { - "line": 88, - "col": 20 - } - }, - "pc": 0 - }, - { - "teal": 175, - "source": { - "start": { - "line": 88, - "col": 17 - }, - "end": { - "line": 88, - "col": 18 - } - }, - "pc": 0 + "source": 78, + "pc": [ + 208, + 209 + ] }, { "teal": 176, - "source": { - "start": { - "line": 88, - "col": 23 - }, - "end": { - "line": 88, - "col": 25 - } - }, - "pc": 0 + "source": 84, + "pc": [ + 210, + 211 + ] }, { "teal": 177, - "source": { - "start": { - "line": 88, - "col": 21 - }, - "end": { - "line": 88, - "col": 22 - } - }, - "pc": 0 - }, - { - "teal": 181, - "source": { - "start": { - "line": 34, - "col": 22 - }, - "end": { - "line": 34, - "col": 25 - } - }, - "pc": 0 - }, - { - "teal": 182, - "source": { - "start": { - "line": 88, - "col": 31 - }, - "end": { - "line": 88, - "col": 32 - } - }, - "pc": 0 - }, - { - "teal": 183, - "source": { - "start": { - "line": 87, - "col": 19 - }, - "end": { - "line": 87, - "col": 20 - } - }, - "pc": 0 + "source": 84, + "pc": [ + 212, + 213 + ] + }, + { + "teal": 178, + "source": 84, + "pc": [ + 214, + 215 + ] + }, + { + "teal": 179, + "source": 84, + "pc": [ + 216 + ] + }, + { + "teal": 180, + "source": 84, + "pc": [ + 217 + ] }, { "teal": 184, - "source": { - "start": { - "line": 88, - "col": 23 - }, - "end": { - "line": 88, - "col": 25 - } - }, - "pc": 0 + "source": 85, + "pc": [ + 218, + 219 + ] }, { "teal": 185, - "source": { - "start": { - "line": 88, - "col": 21 - }, - "end": { - "line": 88, - "col": 22 - } - }, - "pc": 0 + "source": 85, + "pc": [ + 220, + 221 + ] + }, + { + "teal": 186, + "source": 85, + "pc": [ + 222, + 223 + ] + }, + { + "teal": 187, + "source": 85, + "pc": [ + 224 + ] + }, + { + "teal": 188, + "source": 85, + "pc": [ + 225 + ] }, { "teal": 189, - "source": { - "start": { - "line": 34, - "col": 22 - }, - "end": { - "line": 34, - "col": 25 - } - }, - "pc": 0 - }, - { - "teal": 190, - "source": { - "start": { - "line": 88, - "col": 31 - }, - "end": { - "line": 88, - "col": 32 - } - }, - "pc": 0 - }, - { - "teal": 191, - "source": { - "start": { - "line": 87, - "col": 19 - }, - "end": { - "line": 87, - "col": 20 - } - }, - "pc": 0 - }, - { - "teal": 192, - "source": { - "start": { - "line": 83, - "col": 10 - }, - "end": { - "line": 88, - "col": 46 - } - }, - "pc": 0 - }, - { - "teal": 193, - "source": { - "start": { - "line": 90, - "col": 4 - }, - "end": { - "line": 90, - "col": 43 - } - }, - "pc": 0 + "source": 57, + "pc": [ + 226 + ] }, { "teal": 194, - "source": { - "start": { - "line": 90, - "col": 4 - }, - "end": { - "line": 90, - "col": 43 - } - }, - "pc": 0 - }, - { - "teal": 205, - "source": { - "start": { - "line": 91, - "col": 35 - }, - "end": { - "line": 91, - "col": 51 - } - }, - "pc": 0 + "source": 97, + "pc": [ + 227, + 228, + 229 + ] + }, + { + "teal": 195, + "source": 97, + "pc": [ + 230, + 231, + 232 + ] + }, + { + "teal": 198, + "source": 97, + "pc": [ + 233, + 234, + 235 + ] + }, + { + "teal": 199, + "source": 97, + "pc": [ + 236 + ] + }, + { + "teal": 202, + "source": 97, + "pc": [ + 237, + 238, + 239 + ] + }, + { + "teal": 203, + "source": 97, + "pc": [ + 240 + ] }, { "teal": 206, - "source": { - "start": { - "line": 91, - "col": 31 - }, - "end": { - "line": 91, - "col": 34 - } - }, - "pc": 0 + "source": 97, + "pc": [ + 241, + 242, + 243 + ] + }, + { + "teal": 207, + "source": 97, + "pc": [ + 244 + ] + }, + { + "teal": 208, + "source": 97, + "pc": [ + 245 + ] }, { "teal": 209, - "source": { - "start": { - "line": 58, - "col": 2 - }, - "end": { - "line": 92, - "col": 3 - } - }, - "pc": 0 + "source": 97, + "pc": [ + 246 + ] }, { "teal": 210, - "source": { - "start": { - "line": 103, - "col": 2 - }, - "end": { - "line": 117, - "col": 3 - } - }, - "pc": 0 + "source": 97, + "pc": [ + 247 + ] }, { "teal": 213, - "source": { - "start": { - "line": 103, - "col": 2 - }, - "end": { - "line": 117, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 214, - "source": { - "start": { - "line": 103, - "col": 2 - }, - "end": { - "line": 117, - "col": 3 - } - }, - "pc": 0 + "source": 97, + "errorMessage": "argument 3 (pubKey) for upload must be a address", + "pc": [ + 248 + ] + }, + { + "teal": 216, + "source": 97, + "pc": [ + 249, + 250, + 251 + ] }, { "teal": 217, - "source": { - "start": { - "line": 103, - "col": 2 - }, - "end": { - "line": 117, - "col": 3 - } - }, - "pc": 0 + "source": 97, + "pc": [ + 252 + ] }, { "teal": 218, - "source": { - "start": { - "line": 103, - "col": 2 - }, - "end": { - "line": 117, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 221, - "source": { - "start": { - "line": 103, - "col": 2 - }, - "end": { - "line": 117, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 222, - "source": { - "start": { - "line": 103, - "col": 2 - }, - "end": { - "line": 117, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 223, - "source": { - "start": { - "line": 103, - "col": 2 - }, - "end": { - "line": 117, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 224, - "source": { - "start": { - "line": 103, - "col": 60 - }, - "end": { - "line": 103, - "col": 71 - } - }, - "pc": 0 - }, - { - "teal": 225, - "source": { - "start": { - "line": 103, - "col": 60 - }, - "end": { - "line": 103, - "col": 71 - } - }, - "pc": 0 - }, - { - "teal": 226, - "source": { - "start": { - "line": 103, - "col": 60 - }, - "end": { - "line": 103, - "col": 71 - } - }, - "pc": 0 - }, - { - "teal": 229, - "source": { - "start": { - "line": 103, - "col": 44 - }, - "end": { - "line": 103, - "col": 58 - } - }, - "pc": 0 + "source": 97, + "pc": [ + 253 + ] }, { "teal": 230, - "source": { - "start": { - "line": 103, - "col": 44 - }, - "end": { - "line": 103, - "col": 58 - } - }, - "pc": 0 - }, - { - "teal": 231, - "source": { - "start": { - "line": 103, - "col": 26 - }, - "end": { - "line": 103, - "col": 42 - } - }, - "pc": 0 + "source": 97, + "pc": [ + 254, + 255, + 256 + ] }, { "teal": 233, - "source": { - "start": { - "line": 103, - "col": 26 - }, - "end": { - "line": 103, - "col": 42 - } - }, - "pc": 0 - }, - { - "teal": 234, - "source": { - "start": { - "line": 103, - "col": 26 - }, - "end": { - "line": 103, - "col": 42 - } - }, - "pc": 0 + "source": 97, + "pc": [ + 257 + ] + }, + { + "teal": 237, + "source": 98, + "pc": [ + 258, + 259 + ] }, { "teal": 238, - "source": { - "start": { - "line": 103, - "col": 9 - }, - "end": { - "line": 103, - "col": 24 - } - }, - "pc": 0 + "source": 98, + "pc": [ + 260, + 261 + ] }, { "teal": 239, - "source": { - "start": { - "line": 103, - "col": 9 - }, - "end": { - "line": 103, - "col": 24 - } - }, - "pc": 0 + "source": 98, + "pc": [ + 262 + ] }, { "teal": 240, - "source": { - "start": { - "line": 103, - "col": 9 - }, - "end": { - "line": 103, - "col": 24 - } - }, - "pc": 0 - }, - { - "teal": 241, - "source": { - "start": { - "line": 103, - "col": 9 - }, - "end": { - "line": 103, - "col": 24 - } - }, - "pc": 0 + "source": 98, + "pc": [ + 263 + ] + }, + { + "teal": 244, + "source": 100, + "pc": [ + 264, + 265 + ] }, { "teal": 245, - "source": { - "start": { - "line": 103, - "col": 2 - }, - "end": { - "line": 117, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 246, - "source": { - "start": { - "line": 103, - "col": 2 - }, - "end": { - "line": 117, - "col": 3 - } - }, - "pc": 0 + "source": 100, + "pc": [ + 266, + 267 + ] + }, + { + "teal": 249, + "source": 100, + "pc": [ + 268, + 269 + ] }, { "teal": 250, - "source": { - "start": { - "line": 103, - "col": 2 - }, - "end": { - "line": 117, - "col": 3 - } - }, - "pc": 0 + "source": 100, + "pc": [ + 270, + 271 + ] }, { "teal": 251, - "source": { - "start": { - "line": 104, - "col": 4 - }, - "end": { - "line": 104, - "col": 54 - } - }, - "pc": 0 + "source": 100, + "pc": [ + 272 + ] }, { "teal": 252, - "source": { - "start": { - "line": 104, - "col": 4 - }, - "end": { - "line": 104, - "col": 54 - } - }, - "pc": 0 + "source": 100, + "pc": [ + 273 + ] }, { "teal": 253, - "source": { - "start": { - "line": 104, - "col": 11 - }, - "end": { - "line": 104, - "col": 19 - } - }, - "pc": 0 + "source": 101, + "pc": [ + 274 + ] }, { "teal": 254, - "source": { - "start": { - "line": 104, - "col": 31 - }, - "end": { - "line": 104, - "col": 53 - } - }, - "pc": 0 + "source": 26, + "pc": [ + 275 + ] }, { "teal": 255, - "source": { - "start": { - "line": 104, - "col": 27 - }, - "end": { - "line": 104, - "col": 30 - } - }, - "pc": 0 + "source": 101, + "pc": [ + 276 + ] }, { "teal": 256, - "source": { - "start": { - "line": 104, - "col": 11 - }, - "end": { - "line": 104, - "col": 53 - } - }, - "pc": 0 + "source": 101, + "pc": [ + 277 + ] }, { "teal": 260, - "source": { - "start": { - "line": 106, - "col": 35 - }, - "end": { - "line": 106, - "col": 41 - } - }, - "pc": 0 + "source": 100, + "pc": [ + 278, + 279 + ] }, { "teal": 261, - "source": { - "start": { - "line": 106, - "col": 21 - }, - "end": { - "line": 106, - "col": 42 - } - }, - "pc": 0 + "source": 100, + "pc": [ + 280 + ] }, { "teal": 262, - "source": { - "start": { - "line": 106, - "col": 21 - }, - "end": { - "line": 106, - "col": 42 - } - }, - "pc": 0 + "source": 100, + "pc": [ + 281 + ] }, { "teal": 263, - "source": { - "start": { - "line": 107, - "col": 4 - }, - "end": { - "line": 107, - "col": 41 - } - }, - "pc": 0 + "source": 100, + "pc": [ + 282 + ] }, { "teal": 264, - "source": { - "start": { - "line": 106, - "col": 21 - }, - "end": { - "line": 106, - "col": 42 - } - }, - "pc": 0 + "source": 102, + "pc": [ + 283 + ] }, { "teal": 265, - "source": { - "start": { - "line": 106, - "col": 21 - }, - "end": { - "line": 106, - "col": 42 - } - }, - "pc": 0 + "source": 102, + "pc": [ + 284, + 285 + ] }, { "teal": 266, - "source": { - "start": { - "line": 106, - "col": 21 - }, - "end": { - "line": 106, - "col": 42 - } - }, - "pc": 0 + "source": 102, + "pc": [ + 286 + ] }, { "teal": 267, - "source": { - "start": { - "line": 107, - "col": 11 - }, - "end": { - "line": 107, - "col": 26 - } - }, - "pc": 0 + "source": 102, + "pc": [ + 287 + ] }, { "teal": 268, - "source": { - "start": { - "line": 26, - "col": 27 - }, - "end": { - "line": 26, - "col": 28 - } - }, - "pc": 0 + "source": 102, + "pc": [ + 288, + 289, + 290 + ] }, { "teal": 269, - "source": { - "start": { - "line": 26, - "col": 27 - }, - "end": { - "line": 26, - "col": 28 - } - }, - "pc": 0 + "source": 102, + "pc": [ + 291, + 292 + ] }, { "teal": 270, - "source": { - "start": { - "line": 107, - "col": 27 - }, - "end": { - "line": 107, - "col": 30 - } - }, - "pc": 0 + "source": 100, + "pc": [ + 293, + 294 + ] }, { "teal": 271, - "source": { - "start": { - "line": 107, - "col": 11 - }, - "end": { - "line": 107, - "col": 40 - } - }, - "pc": 0 + "source": 100, + "pc": [ + 295 + ] }, { "teal": 272, - "source": { - "start": { - "line": 108, - "col": 4 - }, - "end": { - "line": 108, - "col": 66 - } - }, - "pc": 0 + "source": 100, + "pc": [ + 296 + ] }, { "teal": 273, - "source": { - "start": { - "line": 108, - "col": 4 - }, - "end": { - "line": 108, - "col": 66 - } - }, - "pc": 0 + "source": 100, + "pc": [ + 297 + ] }, { "teal": 274, - "source": { - "start": { - "line": 106, - "col": 21 - }, - "end": { - "line": 106, - "col": 42 - } - }, - "pc": 0 + "source": 102, + "pc": [ + 298 + ] }, { "teal": 275, - "source": { - "start": { - "line": 106, - "col": 21 - }, - "end": { - "line": 106, - "col": 42 - } - }, - "pc": 0 + "source": 102, + "pc": [ + 299 + ] }, { "teal": 276, - "source": { - "start": { - "line": 106, - "col": 21 - }, - "end": { - "line": 106, - "col": 42 - } - }, - "pc": 0 - }, - { - "teal": 278, - "source": { - "start": { - "line": 108, - "col": 11 - }, - "end": { - "line": 108, - "col": 25 - } - }, - "pc": 0 + "source": 102, + "pc": [ + 300 + ] }, { "teal": 279, - "source": { - "start": { - "line": 108, - "col": 11 - }, - "end": { - "line": 108, - "col": 25 - } - }, - "pc": 0 + "source": 102, + "pc": [ + 301 + ] }, { "teal": 284, - "source": { - "start": { - "line": 108, - "col": 38 - }, - "end": { - "line": 108, - "col": 40 - } - }, - "pc": 0 + "source": 104, + "pc": [ + 302, + 303 + ] }, { "teal": 285, - "source": { - "start": { - "line": 108, - "col": 41 - }, - "end": { - "line": 108, - "col": 49 - } - }, - "pc": 0 + "source": 104, + "pc": [ + 304 + ] }, { "teal": 286, - "source": { - "start": { - "line": 106, - "col": 21 - }, - "end": { - "line": 106, - "col": 42 - } - }, - "pc": 0 + "source": 104, + "pc": [ + 305 + ] }, { "teal": 287, - "source": { - "start": { - "line": 106, - "col": 21 - }, - "end": { - "line": 106, - "col": 42 - } - }, - "pc": 0 + "source": 104, + "pc": [ + 306, + 307, + 308 + ] + }, + { + "teal": 292, + "source": 105, + "pc": [ + 309, + 310 + ] + }, + { + "teal": 293, + "source": 105, + "pc": [ + 311 + ] }, { "teal": 294, - "source": { - "start": { - "line": 108, - "col": 38 - }, - "end": { - "line": 108, - "col": 40 - } - }, - "pc": 0 + "source": 105, + "pc": [ + 312, + 313 + ] }, { "teal": 295, - "source": { - "start": { - "line": 108, - "col": 11 - }, - "end": { - "line": 108, - "col": 65 - } - }, - "pc": 0 + "source": 100, + "pc": [ + 314, + 315 + ] }, { "teal": 296, - "source": { - "start": { - "line": 110, - "col": 4 - }, - "end": { - "line": 114, - "col": 5 - } - }, - "pc": 0 + "source": 100, + "pc": [ + 316 + ] }, { "teal": 297, - "source": { - "start": { - "line": 110, - "col": 8 - }, - "end": { - "line": 110, - "col": 20 - } - }, - "pc": 0 + "source": 100, + "pc": [ + 317 + ] }, { "teal": 298, - "source": { - "start": { - "line": 110, - "col": 8 - }, - "end": { - "line": 110, - "col": 20 - } - }, - "pc": 0 + "source": 100, + "pc": [ + 318 + ] }, { "teal": 299, - "source": { - "start": { - "line": 110, - "col": 8 - }, - "end": { - "line": 110, - "col": 14 - } - }, - "pc": 0 + "source": 105, + "pc": [ + 319 + ] }, { "teal": 300, - "source": { - "start": { - "line": 110, - "col": 19 - }, - "end": { - "line": 110, - "col": 20 - } - }, - "pc": 0 + "source": 105, + "pc": [ + 320 + ] }, { "teal": 301, - "source": { - "start": { - "line": 110, - "col": 15 - }, - "end": { - "line": 110, - "col": 18 - } - }, - "pc": 0 + "source": 105, + "pc": [ + 321, + 322, + 323 + ] }, { "teal": 302, - "source": { - "start": { - "line": 110, - "col": 4 - }, - "end": { - "line": 114, - "col": 5 - } - }, - "pc": 0 + "source": 100, + "pc": [ + 324, + 325 + ] }, { "teal": 303, - "source": { - "start": { - "line": 110, - "col": 4 - }, - "end": { - "line": 114, - "col": 5 - } - }, - "pc": 0 + "source": 100, + "pc": [ + 326, + 327 + ] }, { "teal": 304, - "source": { - "start": { - "line": 111, - "col": 6 - }, - "end": { - "line": 113, - "col": 7 - } - }, - "pc": 0 + "source": 100, + "pc": [ + 328 + ] }, { "teal": 305, - "source": { - "start": { - "line": 111, - "col": 6 - }, - "end": { - "line": 113, - "col": 7 - } - }, - "pc": 0 + "source": 100, + "pc": [ + 329 + ] }, { "teal": 306, - "source": { - "start": { - "line": 111, - "col": 6 - }, - "end": { - "line": 113, - "col": 7 - } - }, - "pc": 0 + "source": 105, + "pc": [ + 330 + ] }, { "teal": 307, - "source": { - "start": { - "line": 111, - "col": 6 - }, - "end": { - "line": 113, - "col": 7 - } - }, - "pc": 0 - }, - { - "teal": 308, - "source": { - "start": { - "line": 111, - "col": 21 - }, - "end": { - "line": 111, - "col": 29 - } - }, - "pc": 0 - }, - { - "teal": 309, - "source": { - "start": { - "line": 111, - "col": 21 - }, - "end": { - "line": 111, - "col": 29 - } - }, - "pc": 0 - }, - { - "teal": 311, - "source": { - "start": { - "line": 112, - "col": 8 - }, - "end": { - "line": 112, - "col": 16 - } - }, - "pc": 0 - }, - { - "teal": 312, - "source": { - "start": { - "line": 106, - "col": 21 - }, - "end": { - "line": 106, - "col": 42 - } - }, - "pc": 0 + "source": 105, + "pc": [ + 331, + 332, + 333 + ] + }, + { + "teal": 310, + "source": 105, + "pc": [ + 334, + 335 + ] + }, + { + "teal": 313, + "source": 105, + "pc": [ + 336 + ] }, { "teal": 314, - "source": { - "start": { - "line": 106, - "col": 21 - }, - "end": { - "line": 106, - "col": 42 - } - }, - "pc": 0 - }, - { - "teal": 315, - "source": { - "start": { - "line": 106, - "col": 21 - }, - "end": { - "line": 106, - "col": 42 - } - }, - "pc": 0 - }, - { - "teal": 317, - "source": { - "start": { - "line": 112, - "col": 21 - }, - "end": { - "line": 112, - "col": 33 - } - }, - "pc": 0 + "source": 105, + "pc": [ + 337 + ] + }, + { + "teal": 319, + "source": 108, + "pc": [ + 338, + 339 + ] }, { "teal": 320, - "source": { - "start": { - "line": 112, - "col": 8 - }, - "end": { - "line": 112, - "col": 67 - } - }, - "pc": 0 + "source": 108, + "pc": [ + 340 + ] }, { "teal": 321, - "source": { - "start": { - "line": 106, - "col": 21 - }, - "end": { - "line": 106, - "col": 42 - } - }, - "pc": 0 + "source": 108, + "pc": [ + 341, + 342 + ] }, { "teal": 322, - "source": { - "start": { - "line": 106, - "col": 21 - }, - "end": { - "line": 106, - "col": 42 - } - }, - "pc": 0 + "source": 108, + "pc": [ + 343, + 344 + ] }, { "teal": 323, - "source": { - "start": { - "line": 106, - "col": 21 - }, - "end": { - "line": 106, - "col": 42 - } - }, - "pc": 0 + "source": 108, + "pc": [ + 345 + ] }, { "teal": 324, - "source": { - "start": { - "line": 112, - "col": 36 - }, - "end": { - "line": 112, - "col": 52 - } - }, - "pc": 0 - }, - { - "teal": 325, - "source": { - "start": { - "line": 112, - "col": 36 - }, - "end": { - "line": 112, - "col": 52 - } - }, - "pc": 0 + "source": 97, + "pc": [ + 346 + ] + }, + { + "teal": 329, + "source": 117, + "pc": [ + 347, + 348, + 349 + ] + }, + { + "teal": 330, + "source": 117, + "pc": [ + 350 + ] + }, + { + "teal": 331, + "source": 117, + "pc": [ + 351 + ] + }, + { + "teal": 332, + "source": 117, + "pc": [ + 352 + ] }, { "teal": 333, - "source": { - "start": { - "line": 116, - "col": 4 - }, - "end": { - "line": 116, - "col": 50 - } - }, - "pc": 0 - }, - { - "teal": 335, - "source": { - "start": { - "line": 116, - "col": 19 - }, - "end": { - "line": 116, - "col": 27 - } - }, - "pc": 0 + "source": 117, + "pc": [ + 353 + ] }, { "teal": 336, - "source": { - "start": { - "line": 116, - "col": 37 - }, - "end": { - "line": 116, - "col": 43 - } - }, - "pc": 0 - }, - { - "teal": 337, - "source": { - "start": { - "line": 116, - "col": 45 - }, - "end": { - "line": 116, - "col": 49 - } - }, - "pc": 0 - }, - { - "teal": 338, - "source": { - "start": { - "line": 116, - "col": 4 - }, - "end": { - "line": 116, - "col": 28 - } - }, - "pc": 0 + "source": 117, + "errorMessage": "argument 0 (pubKey) for finishUpload must be a address", + "pc": [ + 354 + ] }, { "teal": 339, - "source": { - "start": { - "line": 103, - "col": 2 - }, - "end": { - "line": 117, - "col": 3 - } - }, - "pc": 0 + "source": 117, + "pc": [ + 355, + 356, + 357 + ] }, { "teal": 340, - "source": { - "start": { - "line": 125, - "col": 2 - }, - "end": { - "line": 129, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 343, - "source": { - "start": { - "line": 125, - "col": 2 - }, - "end": { - "line": 129, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 344, - "source": { - "start": { - "line": 125, - "col": 2 - }, - "end": { - "line": 129, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 345, - "source": { - "start": { - "line": 125, - "col": 2 - }, - "end": { - "line": 129, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 347, - "source": { - "start": { - "line": 125, - "col": 2 - }, - "end": { - "line": 129, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 348, - "source": { - "start": { - "line": 125, - "col": 2 - }, - "end": { - "line": 129, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 352, - "source": { - "start": { - "line": 125, - "col": 15 - }, - "end": { - "line": 125, - "col": 30 - } - }, - "pc": 0 - }, - { - "teal": 353, - "source": { - "start": { - "line": 125, - "col": 15 - }, - "end": { - "line": 125, - "col": 30 - } - }, - "pc": 0 + "source": 117, + "pc": [ + 358 + ] + }, + { + "teal": 341, + "source": 117, + "pc": [ + 359 + ] + }, + { + "teal": 350, + "source": 117, + "pc": [ + 360, + 361, + 362 + ] }, { "teal": 354, - "source": { - "start": { - "line": 125, - "col": 15 - }, - "end": { - "line": 125, - "col": 30 - } - }, - "pc": 0 + "source": 118, + "pc": [ + 363, + 364 + ] }, { "teal": 355, - "source": { - "start": { - "line": 125, - "col": 15 - }, - "end": { - "line": 125, - "col": 30 - } - }, - "pc": 0 - }, - { - "teal": 359, - "source": { - "start": { - "line": 125, - "col": 2 - }, - "end": { - "line": 129, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 360, - "source": { - "start": { - "line": 125, - "col": 2 - }, - "end": { - "line": 129, - "col": 3 - } - }, - "pc": 0 + "source": 118, + "pc": [ + 365, + 366 + ] + }, + { + "teal": 356, + "source": 118, + "pc": [ + 367 + ] + }, + { + "teal": 357, + "source": 118, + "pc": [ + 368 + ] }, { "teal": 361, - "source": { - "start": { - "line": 125, - "col": 2 - }, - "end": { - "line": 129, - "col": 3 - } - }, - "pc": 0 + "source": 120, + "pc": [ + 369, + 370 + ] }, { "teal": 362, - "source": { - "start": { - "line": 125, - "col": 2 - }, - "end": { - "line": 129, - "col": 3 - } - }, - "pc": 0 + "source": 120, + "pc": [ + 371, + 372 + ] }, { "teal": 363, - "source": { - "start": { - "line": 125, - "col": 2 - }, - "end": { - "line": 129, - "col": 3 - } - }, - "pc": 0 + "source": 120, + "pc": [ + 373, + 374, + 375 + ] + }, + { + "teal": 364, + "source": 120, + "pc": [ + 376 + ] + }, + { + "teal": 365, + "source": 117, + "pc": [ + 377 + ] }, { "teal": 370, - "source": { - "start": { - "line": 126, - "col": 27 - }, - "end": { - "line": 126, - "col": 30 - } - }, - "pc": 0 + "source": 128, + "pc": [ + 378, + 379, + 380 + ] }, { "teal": 371, - "source": { - "start": { - "line": 126, - "col": 11 - }, - "end": { - "line": 126, - "col": 53 - } - }, - "pc": 0 + "source": 128, + "pc": [ + 381 + ] + }, + { + "teal": 372, + "source": 128, + "pc": [ + 382 + ] + }, + { + "teal": 373, + "source": 128, + "pc": [ + 383 + ] }, { "teal": 374, - "source": { - "start": { - "line": 128, - "col": 4 - }, - "end": { - "line": 128, - "col": 46 - } - }, - "pc": 0 - }, - { - "teal": 375, - "source": { - "start": { - "line": 128, - "col": 18 - }, - "end": { - "line": 128, - "col": 24 - } - }, - "pc": 0 - }, - { - "teal": 376, - "source": { - "start": { - "line": 128, - "col": 4 - }, - "end": { - "line": 128, - "col": 25 - } - }, - "pc": 0 + "source": 128, + "pc": [ + 384 + ] }, { "teal": 377, - "source": { - "start": { - "line": 128, - "col": 4 - }, - "end": { - "line": 128, - "col": 25 - } - }, - "pc": 0 - }, - { - "teal": 378, - "source": { - "start": { - "line": 128, - "col": 4 - }, - "end": { - "line": 128, - "col": 38 - } - }, - "pc": 0 - }, - { - "teal": 379, - "source": { - "start": { - "line": 128, - "col": 4 - }, - "end": { - "line": 128, - "col": 25 - } - }, - "pc": 0 + "source": 128, + "errorMessage": "argument 0 (pubKey) for startDelete must be a address", + "pc": [ + 385 + ] + }, + { + "teal": 380, + "source": 128, + "pc": [ + 386, + 387, + 388 + ] + }, + { + "teal": 381, + "source": 128, + "pc": [ + 389 + ] }, { "teal": 382, - "source": { - "start": { - "line": 136, - "col": 2 - }, - "end": { - "line": 143, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 383, - "source": { - "start": { - "line": 136, - "col": 2 - }, - "end": { - "line": 143, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 384, - "source": { - "start": { - "line": 136, - "col": 2 - }, - "end": { - "line": 143, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 386, - "source": { - "start": { - "line": 136, - "col": 2 - }, - "end": { - "line": 143, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 387, - "source": { - "start": { - "line": 136, - "col": 2 - }, - "end": { - "line": 143, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 391, - "source": { - "start": { - "line": 136, - "col": 14 - }, - "end": { - "line": 136, - "col": 29 - } - }, - "pc": 0 - }, - { - "teal": 392, - "source": { - "start": { - "line": 136, - "col": 14 - }, - "end": { - "line": 136, - "col": 29 - } - }, - "pc": 0 + "source": 128, + "pc": [ + 390 + ] + }, + { + "teal": 390, + "source": 128, + "pc": [ + 391, + 392, + 393 + ] }, { "teal": 393, - "source": { - "start": { - "line": 136, - "col": 14 - }, - "end": { - "line": 136, - "col": 29 - } - }, - "pc": 0 - }, - { - "teal": 394, - "source": { - "start": { - "line": 136, - "col": 14 - }, - "end": { - "line": 136, - "col": 29 - } - }, - "pc": 0 + "source": 128, + "pc": [ + 394 + ] + }, + { + "teal": 397, + "source": 129, + "pc": [ + 395, + 396 + ] }, { "teal": 398, - "source": { - "start": { - "line": 136, - "col": 14 - }, - "end": { - "line": 136, - "col": 29 - } - }, - "pc": 0 + "source": 129, + "pc": [ + 397, + 398 + ] }, { "teal": 399, - "source": { - "start": { - "line": 136, - "col": 2 - }, - "end": { - "line": 143, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 403, - "source": { - "start": { - "line": 136, - "col": 2 - }, - "end": { - "line": 143, - "col": 3 - } - }, - "pc": 0 + "source": 129, + "pc": [ + 399 + ] + }, + { + "teal": 400, + "source": 129, + "pc": [ + 400 + ] }, { "teal": 404, - "source": { - "start": { - "line": 136, - "col": 2 - }, - "end": { - "line": 143, - "col": 3 - } - }, - "pc": 0 + "source": 131, + "pc": [ + 401, + 402 + ] }, { "teal": 405, - "source": { - "start": { - "line": 136, - "col": 2 - }, - "end": { - "line": 143, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 406, - "source": { - "start": { - "line": 137, - "col": 4 - }, - "end": { - "line": 137, - "col": 54 - } - }, - "pc": 0 - }, - { - "teal": 407, - "source": { - "start": { - "line": 137, - "col": 4 - }, - "end": { - "line": 137, - "col": 54 - } - }, - "pc": 0 - }, - { - "teal": 408, - "source": { - "start": { - "line": 137, - "col": 11 - }, - "end": { - "line": 137, - "col": 19 - } - }, - "pc": 0 + "source": 131, + "pc": [ + 403, + 404 + ] }, { "teal": 409, - "source": { - "start": { - "line": 137, - "col": 31 - }, - "end": { - "line": 137, - "col": 53 - } - }, - "pc": 0 + "source": 131, + "pc": [ + 405, + 406 + ] + }, + { + "teal": 410, + "source": 131, + "pc": [ + 407, + 408 + ] + }, + { + "teal": 411, + "source": 131, + "pc": [ + 409 + ] + }, + { + "teal": 412, + "source": 131, + "pc": [ + 410 + ] }, { "teal": 413, - "source": { - "start": { - "line": 139, - "col": 21 - }, - "end": { - "line": 139, - "col": 48 - } - }, - "pc": 0 + "source": 132, + "pc": [ + 411 + ] }, { "teal": 414, - "source": { - "start": { - "line": 139, - "col": 21 - }, - "end": { - "line": 139, - "col": 48 - } - }, - "pc": 0 + "source": 29, + "pc": [ + 412 + ] }, { "teal": 415, - "source": { - "start": { - "line": 139, - "col": 35 - }, - "end": { - "line": 139, - "col": 41 - } - }, - "pc": 0 + "source": 132, + "pc": [ + 413 + ] }, { "teal": 416, - "source": { - "start": { - "line": 139, - "col": 21 - }, - "end": { - "line": 139, - "col": 42 - } - }, - "pc": 0 - }, - { - "teal": 417, - "source": { - "start": { - "line": 139, - "col": 21 - }, - "end": { - "line": 139, - "col": 42 - } - }, - "pc": 0 - }, - { - "teal": 418, - "source": { - "start": { - "line": 140, - "col": 4 - }, - "end": { - "line": 140, - "col": 37 - } - }, - "pc": 0 - }, - { - "teal": 419, - "source": { - "start": { - "line": 139, - "col": 21 - }, - "end": { - "line": 139, - "col": 42 - } - }, - "pc": 0 + "source": 132, + "pc": [ + 414 + ] }, { "teal": 420, - "source": { - "start": { - "line": 139, - "col": 21 - }, - "end": { - "line": 139, - "col": 42 - } - }, - "pc": 0 + "source": 131, + "pc": [ + 415, + 416 + ] }, { "teal": 421, - "source": { - "start": { - "line": 139, - "col": 21 - }, - "end": { - "line": 139, - "col": 42 - } - }, - "pc": 0 + "source": 131, + "pc": [ + 417, + 418 + ] + }, + { + "teal": 422, + "source": 131, + "pc": [ + 419, + 420, + 421 + ] + }, + { + "teal": 423, + "source": 131, + "pc": [ + 422 + ] + }, + { + "teal": 424, + "source": 128, + "pc": [ + 423 + ] }, { "teal": 429, - "source": { - "start": { - "line": 142, - "col": 4 - }, - "end": { - "line": 142, - "col": 30 - } - }, - "pc": 0 + "source": 143, + "pc": [ + 424, + 425, + 426 + ] }, { "teal": 430, - "source": { - "start": { - "line": 139, - "col": 21 - }, - "end": { - "line": 139, - "col": 42 - } - }, - "pc": 0 + "source": 143, + "pc": [ + 427 + ] }, { "teal": 433, - "source": { - "start": { - "line": 139, - "col": 21 - }, - "end": { - "line": 139, - "col": 42 - } - }, - "pc": 0 + "source": 143, + "pc": [ + 428, + 429, + 430 + ] }, { "teal": 434, - "source": { - "start": { - "line": 142, - "col": 4 - }, - "end": { - "line": 142, - "col": 19 - } - }, - "pc": 0 + "source": 143, + "pc": [ + 431 + ] + }, + { + "teal": 435, + "source": 143, + "pc": [ + 432 + ] + }, + { + "teal": 436, + "source": 143, + "pc": [ + 433 + ] }, { "teal": 437, - "source": { - "start": { - "line": 139, - "col": 21 - }, - "end": { - "line": 139, - "col": 42 - } - }, - "pc": 0 - }, - { - "teal": 438, - "source": { - "start": { - "line": 139, - "col": 21 - }, - "end": { - "line": 139, - "col": 42 - } - }, - "pc": 0 - }, - { - "teal": 439, - "source": { - "start": { - "line": 139, - "col": 21 - }, - "end": { - "line": 139, - "col": 42 - } - }, - "pc": 0 + "source": 143, + "pc": [ + 434 + ] }, { "teal": 440, - "source": { - "start": { - "line": 136, - "col": 2 - }, - "end": { - "line": 143, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 441, - "source": { - "start": { - "line": 151, - "col": 2 - }, - "end": { - "line": 173, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 442, - "source": { - "start": { - "line": 151, - "col": 2 - }, - "end": { - "line": 173, - "col": 3 - } - }, - "pc": 0 + "source": 143, + "errorMessage": "argument 1 (pubKey) for deleteData must be a address", + "pc": [ + 435 + ] + }, + { + "teal": 443, + "source": 143, + "pc": [ + 436, + 437, + 438 + ] + }, + { + "teal": 444, + "source": 143, + "pc": [ + 439 + ] }, { "teal": 445, - "source": { - "start": { - "line": 151, - "col": 2 - }, - "end": { - "line": 173, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 446, - "source": { - "start": { - "line": 151, - "col": 2 - }, - "end": { - "line": 173, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 447, - "source": { - "start": { - "line": 151, - "col": 2 - }, - "end": { - "line": 173, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 449, - "source": { - "start": { - "line": 151, - "col": 2 - }, - "end": { - "line": 173, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 450, - "source": { - "start": { - "line": 151, - "col": 2 - }, - "end": { - "line": 173, - "col": 3 - } - }, - "pc": 0 + "source": 143, + "pc": [ + 440 + ] }, { "teal": 454, - "source": { - "start": { - "line": 151, - "col": 30 - }, - "end": { - "line": 151, - "col": 46 - } - }, - "pc": 0 - }, - { - "teal": 455, - "source": { - "start": { - "line": 151, - "col": 13 - }, - "end": { - "line": 151, - "col": 28 - } - }, - "pc": 0 - }, - { - "teal": 456, - "source": { - "start": { - "line": 151, - "col": 13 - }, - "end": { - "line": 151, - "col": 28 - } - }, - "pc": 0 + "source": 143, + "pc": [ + 441, + 442, + 443 + ] }, { "teal": 457, - "source": { - "start": { - "line": 151, - "col": 13 - }, - "end": { - "line": 151, - "col": 28 - } - }, - "pc": 0 - }, - { - "teal": 461, - "source": { - "start": { - "line": 151, - "col": 13 - }, - "end": { - "line": 151, - "col": 28 - } - }, - "pc": 0 + "source": 143, + "pc": [ + 444 + ] + }, + { + "teal": 458, + "source": 143, + "pc": [ + 445 + ] }, { "teal": 462, - "source": { - "start": { - "line": 151, - "col": 13 - }, - "end": { - "line": 151, - "col": 28 - } - }, - "pc": 0 - }, - { - "teal": 466, - "source": { - "start": { - "line": 151, - "col": 2 - }, - "end": { - "line": 173, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 467, - "source": { - "start": { - "line": 151, - "col": 2 - }, - "end": { - "line": 173, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 468, - "source": { - "start": { - "line": 151, - "col": 2 - }, - "end": { - "line": 173, - "col": 3 - } - }, - "pc": 0 + "source": 144, + "pc": [ + 446, + 447 + ] + }, + { + "teal": 463, + "source": 144, + "pc": [ + 448, + 449 + ] + }, + { + "teal": 464, + "source": 144, + "pc": [ + 450 + ] + }, + { + "teal": 465, + "source": 144, + "pc": [ + 451 + ] }, { "teal": 469, - "source": { - "start": { - "line": 151, - "col": 2 - }, - "end": { - "line": 173, - "col": 3 - } - }, - "pc": 0 + "source": 146, + "pc": [ + 452, + 453 + ] }, { "teal": 470, - "source": { - "start": { - "line": 152, - "col": 4 - }, - "end": { - "line": 152, - "col": 54 - } - }, - "pc": 0 - }, - { - "teal": 471, - "source": { - "start": { - "line": 152, - "col": 4 - }, - "end": { - "line": 152, - "col": 54 - } - }, - "pc": 0 - }, - { - "teal": 472, - "source": { - "start": { - "line": 152, - "col": 11 - }, - "end": { - "line": 152, - "col": 19 - } - }, - "pc": 0 + "source": 146, + "pc": [ + 454, + 455 + ] + }, + { + "teal": 474, + "source": 146, + "pc": [ + 456, + 457 + ] + }, + { + "teal": 475, + "source": 146, + "pc": [ + 458, + 459 + ] }, { "teal": 476, - "source": { - "start": { - "line": 152, - "col": 11 - }, - "end": { - "line": 152, - "col": 53 - } - }, - "pc": 0 + "source": 146, + "pc": [ + 460 + ] }, { "teal": 477, - "source": { - "start": { - "line": 154, - "col": 21 - }, - "end": { - "line": 154, - "col": 48 - } - }, - "pc": 0 + "source": 146, + "pc": [ + 461 + ] }, { "teal": 478, - "source": { - "start": { - "line": 154, - "col": 21 - }, - "end": { - "line": 154, - "col": 48 - } - }, - "pc": 0 + "source": 147, + "pc": [ + 462 + ] }, { "teal": 479, - "source": { - "start": { - "line": 154, - "col": 35 - }, - "end": { - "line": 154, - "col": 41 - } - }, - "pc": 0 + "source": 32, + "pc": [ + 463, + 464 + ] }, { "teal": 480, - "source": { - "start": { - "line": 154, - "col": 21 - }, - "end": { - "line": 154, - "col": 42 - } - }, - "pc": 0 + "source": 147, + "pc": [ + 465 + ] }, { "teal": 481, - "source": { - "start": { - "line": 154, - "col": 21 - }, - "end": { - "line": 154, - "col": 42 - } - }, - "pc": 0 - }, - { - "teal": 482, - "source": { - "start": { - "line": 155, - "col": 4 - }, - "end": { - "line": 155, - "col": 40 - } - }, - "pc": 0 - }, - { - "teal": 483, - "source": { - "start": { - "line": 154, - "col": 21 - }, - "end": { - "line": 154, - "col": 42 - } - }, - "pc": 0 - }, - { - "teal": 484, - "source": { - "start": { - "line": 154, - "col": 21 - }, - "end": { - "line": 154, - "col": 42 - } - }, - "pc": 0 + "source": 147, + "pc": [ + 466 + ] }, { "teal": 485, - "source": { - "start": { - "line": 154, - "col": 21 - }, - "end": { - "line": 154, - "col": 42 - } - }, - "pc": 0 + "source": 146, + "pc": [ + 467, + 468 + ] }, { "teal": 486, - "source": { - "start": { - "line": 155, - "col": 11 - }, - "end": { - "line": 155, - "col": 26 - } - }, - "pc": 0 + "source": 146, + "pc": [ + 469 + ] }, { "teal": 487, - "source": { - "start": { - "line": 32, - "col": 26 - }, - "end": { - "line": 32, - "col": 27 - } - }, - "pc": 0 + "source": 146, + "pc": [ + 470 + ] }, { "teal": 488, - "source": { - "start": { - "line": 32, - "col": 26 - }, - "end": { - "line": 32, - "col": 27 - } - }, - "pc": 0 + "source": 146, + "pc": [ + 471 + ] }, { "teal": 489, - "source": { - "start": { - "line": 155, - "col": 27 - }, - "end": { - "line": 155, - "col": 30 - } - }, - "pc": 0 + "source": 148, + "pc": [ + 472 + ] }, { "teal": 490, - "source": { - "start": { - "line": 155, - "col": 11 - }, - "end": { - "line": 155, - "col": 39 - } - }, - "pc": 0 + "source": 148, + "pc": [ + 473, + 474 + ] }, { "teal": 491, - "source": { - "start": { - "line": 156, - "col": 4 - }, - "end": { - "line": 156, - "col": 66 - } - }, - "pc": 0 + "source": 148, + "pc": [ + 475 + ] }, { "teal": 492, - "source": { - "start": { - "line": 156, - "col": 4 - }, - "end": { - "line": 156, - "col": 66 - } - }, - "pc": 0 + "source": 148, + "pc": [ + 476 + ] + }, + { + "teal": 493, + "source": 148, + "pc": [ + 477, + 478, + 479 + ] }, { "teal": 494, - "source": { - "start": { - "line": 154, - "col": 21 - }, - "end": { - "line": 154, - "col": 42 - } - }, - "pc": 0 + "source": 148, + "pc": [ + 480, + 481 + ] }, { "teal": 495, - "source": { - "start": { - "line": 154, - "col": 21 - }, - "end": { - "line": 154, - "col": 42 - } - }, - "pc": 0 + "source": 146, + "pc": [ + 482, + 483 + ] + }, + { + "teal": 496, + "source": 146, + "pc": [ + 484 + ] + }, + { + "teal": 497, + "source": 146, + "pc": [ + 485 + ] + }, + { + "teal": 498, + "source": 146, + "pc": [ + 486 + ] + }, + { + "teal": 499, + "source": 148, + "pc": [ + 487 + ] }, { "teal": 500, - "source": { - "start": { - "line": 156, - "col": 29 - }, - "end": { - "line": 156, - "col": 37 - } - }, - "pc": 0 + "source": 148, + "pc": [ + 488 + ] }, { "teal": 501, - "source": { - "start": { - "line": 156, - "col": 26 - }, - "end": { - "line": 156, - "col": 28 - } - }, - "pc": 0 - }, - { - "teal": 502, - "source": { - "start": { - "line": 156, - "col": 38 - }, - "end": { - "line": 156, - "col": 40 - } - }, - "pc": 0 - }, - { - "teal": 503, - "source": { - "start": { - "line": 156, - "col": 38 - }, - "end": { - "line": 156, - "col": 40 - } - }, - "pc": 0 + "source": 148, + "pc": [ + 489 + ] }, { "teal": 504, - "source": { - "start": { - "line": 156, - "col": 41 - }, - "end": { - "line": 156, - "col": 49 - } - }, - "pc": 0 - }, - { - "teal": 505, - "source": { - "start": { - "line": 154, - "col": 21 - }, - "end": { - "line": 154, - "col": 42 - } - }, - "pc": 0 - }, - { - "teal": 506, - "source": { - "start": { - "line": 154, - "col": 21 - }, - "end": { - "line": 154, - "col": 42 - } - }, - "pc": 0 - }, - { - "teal": 507, - "source": { - "start": { - "line": 154, - "col": 21 - }, - "end": { - "line": 154, - "col": 42 - } - }, - "pc": 0 + "source": 148, + "pc": [ + 490 + ] + }, + { + "teal": 509, + "source": 150, + "pc": [ + 491, + 492 + ] + }, + { + "teal": 510, + "source": 146, + "pc": [ + 493, + 494 + ] + }, + { + "teal": 511, + "source": 146, + "pc": [ + 495 + ] }, { "teal": 512, - "source": { - "start": { - "line": 156, - "col": 38 - }, - "end": { - "line": 156, - "col": 40 - } - }, - "pc": 0 + "source": 146, + "pc": [ + 496 + ] }, { "teal": 513, - "source": { - "start": { - "line": 156, - "col": 38 - }, - "end": { - "line": 156, - "col": 40 - } - }, - "pc": 0 + "source": 146, + "pc": [ + 497 + ] }, { "teal": 514, - "source": { - "start": { - "line": 156, - "col": 11 - }, - "end": { - "line": 156, - "col": 65 - } - }, - "pc": 0 + "source": 150, + "pc": [ + 498 + ] }, { "teal": 515, - "source": { - "start": { - "line": 158, - "col": 4 - }, - "end": { - "line": 160, - "col": 5 - } - }, - "pc": 0 + "source": 150, + "pc": [ + 499 + ] }, { "teal": 516, - "source": { - "start": { - "line": 158, - "col": 8 - }, - "end": { - "line": 158, - "col": 35 - } - }, - "pc": 0 - }, - { - "teal": 517, - "source": { - "start": { - "line": 158, - "col": 8 - }, - "end": { - "line": 158, - "col": 35 - } - }, - "pc": 0 - }, - { - "teal": 518, - "source": { - "start": { - "line": 158, - "col": 8 - }, - "end": { - "line": 158, - "col": 16 - } - }, - "pc": 0 - }, - { - "teal": 519, - "source": { - "start": { - "line": 154, - "col": 21 - }, - "end": { - "line": 154, - "col": 42 - } - }, - "pc": 0 - }, - { - "teal": 520, - "source": { - "start": { - "line": 154, - "col": 21 - }, - "end": { - "line": 154, - "col": 42 - } - }, - "pc": 0 + "source": 150, + "pc": [ + 500, + 501, + 502 + ] }, { "teal": 521, - "source": { - "start": { - "line": 154, - "col": 21 - }, - "end": { - "line": 154, - "col": 42 - } - }, - "pc": 0 + "source": 146, + "pc": [ + 503, + 504 + ] + }, + { + "teal": 522, + "source": 146, + "pc": [ + 505, + 506 + ] }, { "teal": 523, - "source": { - "start": { - "line": 158, - "col": 21 - }, - "end": { - "line": 158, - "col": 35 - } - }, - "pc": 0 + "source": 146, + "pc": [ + 507 + ] + }, + { + "teal": 524, + "source": 146, + "pc": [ + 508 + ] + }, + { + "teal": 525, + "source": 150, + "pc": [ + 509 + ] }, { "teal": 526, - "source": { - "start": { - "line": 158, - "col": 4 - }, - "end": { - "line": 160, - "col": 5 - } - }, - "pc": 0 + "source": 150, + "pc": [ + 510, + 511 + ] }, { "teal": 527, - "source": { - "start": { - "line": 158, - "col": 4 - }, - "end": { - "line": 160, - "col": 5 - } - }, - "pc": 0 + "source": 150, + "pc": [ + 512 + ] }, { "teal": 528, - "source": { - "start": { - "line": 159, - "col": 6 - }, - "end": { - "line": 159, - "col": 51 - } - }, - "pc": 0 + "source": 150, + "pc": [ + 513 + ] }, { "teal": 529, - "source": { - "start": { - "line": 159, - "col": 6 - }, - "end": { - "line": 159, - "col": 51 - } - }, - "pc": 0 - }, - { - "teal": 533, - "source": { - "start": { - "line": 154, - "col": 21 - }, - "end": { - "line": 154, - "col": 42 - } - }, - "pc": 0 - }, - { - "teal": 534, - "source": { - "start": { - "line": 159, - "col": 13 - }, - "end": { - "line": 159, - "col": 33 - } - }, - "pc": 0 + "source": 150, + "pc": [ + 514 + ] + }, + { + "teal": 530, + "source": 150, + "pc": [ + 515 + ] }, { "teal": 535, - "source": { - "start": { - "line": 159, - "col": 13 - }, - "end": { - "line": 159, - "col": 33 - } - }, - "pc": 0 - }, - { - "teal": 540, - "source": { - "start": { - "line": 159, - "col": 34 - }, - "end": { - "line": 159, - "col": 37 - } - }, - "pc": 0 - }, - { - "teal": 541, - "source": { - "start": { - "line": 159, - "col": 13 - }, - "end": { - "line": 159, - "col": 50 - } - }, - "pc": 0 + "source": 152, + "pc": [ + 516, + 517 + ] + }, + { + "teal": 536, + "source": 152, + "pc": [ + 518, + 519 + ] + }, + { + "teal": 537, + "source": 152, + "pc": [ + 520 + ] + }, + { + "teal": 538, + "source": 152, + "pc": [ + 521, + 522 + ] }, { "teal": 542, - "source": { - "start": { - "line": 158, - "col": 4 - }, - "end": { - "line": 160, - "col": 5 - } - }, - "pc": 0 + "source": 154, + "pc": [ + 523, + 524 + ] }, { "teal": 543, - "source": { - "start": { - "line": 162, - "col": 19 - }, - "end": { - "line": 162, - "col": 63 - } - }, - "pc": 0 + "source": 154, + "pc": [ + 525 + ] }, { "teal": 544, - "source": { - "start": { - "line": 162, - "col": 19 - }, - "end": { - "line": 162, - "col": 63 - } - }, - "pc": 0 - }, - { - "teal": 545, - "source": { - "start": { - "line": 162, - "col": 19 - }, - "end": { - "line": 162, - "col": 52 - } - }, - "pc": 0 - }, - { - "teal": 546, - "source": { - "start": { - "line": 162, - "col": 19 - }, - "end": { - "line": 162, - "col": 63 - } - }, - "pc": 0 - }, - { - "teal": 547, - "source": { - "start": { - "line": 162, - "col": 19 - }, - "end": { - "line": 162, - "col": 63 - } - }, - "pc": 0 + "source": 154, + "pc": [ + 526 + ] + }, + { + "teal": 549, + "source": 156, + "pc": [ + 527, + 528 + ] + }, + { + "teal": 550, + "source": 146, + "pc": [ + 529, + 530 + ] + }, + { + "teal": 551, + "source": 146, + "pc": [ + 531 + ] }, { "teal": 552, - "source": { - "start": { - "line": 164, - "col": 19 - }, - "end": { - "line": 164, - "col": 27 - } - }, - "pc": 0 + "source": 146, + "pc": [ + 532 + ] }, { "teal": 553, - "source": { - "start": { - "line": 164, - "col": 19 - }, - "end": { - "line": 164, - "col": 27 - } - }, - "pc": 0 + "source": 146, + "pc": [ + 533 + ] }, { "teal": 554, - "source": { - "start": { - "line": 164, - "col": 4 - }, - "end": { - "line": 164, - "col": 28 - } - }, - "pc": 0 + "source": 156, + "pc": [ + 534 + ] + }, + { + "teal": 555, + "source": 156, + "pc": [ + 535 + ] }, { "teal": 556, - "source": { - "start": { - "line": 166, - "col": 4 - }, - "end": { - "line": 167, - "col": 41 - } - }, - "pc": 0 - }, - { - "teal": 559, - "source": { - "start": { - "line": 166, - "col": 8 - }, - "end": { - "line": 166, - "col": 16 - } - }, - "pc": 0 - }, - { - "teal": 560, - "source": { - "start": { - "line": 154, - "col": 21 - }, - "end": { - "line": 154, - "col": 42 - } - }, - "pc": 0 + "source": 156, + "pc": [ + 536, + 537, + 538 + ] }, { "teal": 561, - "source": { - "start": { - "line": 154, - "col": 21 - }, - "end": { - "line": 154, - "col": 42 - } - }, - "pc": 0 + "source": 156, + "pc": [ + 539, + 540 + ] }, { "teal": 562, - "source": { - "start": { - "line": 154, - "col": 21 - }, - "end": { - "line": 154, - "col": 42 - } - }, - "pc": 0 + "source": 156, + "pc": [ + 541 + ] }, { "teal": 563, - "source": { - "start": { - "line": 166, - "col": 21 - }, - "end": { - "line": 166, - "col": 33 - } - }, - "pc": 0 - }, - { - "teal": 564, - "source": { - "start": { - "line": 166, - "col": 21 - }, - "end": { - "line": 166, - "col": 33 - } - }, - "pc": 0 - }, - { - "teal": 565, - "source": { - "start": { - "line": 166, - "col": 17 - }, - "end": { - "line": 166, - "col": 20 - } - }, - "pc": 0 - }, - { - "teal": 566, - "source": { - "start": { - "line": 166, - "col": 4 - }, - "end": { - "line": 167, - "col": 41 - } - }, - "pc": 0 - }, - { - "teal": 567, - "source": { - "start": { - "line": 166, - "col": 4 - }, - "end": { - "line": 167, - "col": 41 - } - }, - "pc": 0 + "source": 156, + "pc": [ + 542, + 543, + 544 + ] + }, + { + "teal": 568, + "source": 157, + "pc": [ + 545, + 546 + ] }, { "teal": 569, - "source": { - "start": { - "line": 166, - "col": 35 - }, - "end": { - "line": 166, - "col": 65 - } - }, - "pc": 0 - }, - { - "teal": 575, - "source": { - "start": { - "line": 167, - "col": 9 - }, - "end": { - "line": 167, - "col": 40 - } - }, - "pc": 0 - }, - { - "teal": 576, - "source": { - "start": { - "line": 167, - "col": 9 - }, - "end": { - "line": 167, - "col": 40 - } - }, - "pc": 0 - }, - { - "teal": 577, - "source": { - "start": { - "line": 154, - "col": 21 - }, - "end": { - "line": 154, - "col": 42 - } - }, - "pc": 0 + "source": 157, + "pc": [ + 547, + 548 + ] + }, + { + "teal": 570, + "source": 157, + "pc": [ + 549 + ] + }, + { + "teal": 571, + "source": 146, + "pc": [ + 550, + 551 + ] + }, + { + "teal": 572, + "source": 146, + "pc": [ + 552, + 553 + ] + }, + { + "teal": 573, + "source": 146, + "pc": [ + 554 + ] }, { "teal": 581, - "source": { - "start": { - "line": 167, - "col": 9 - }, - "end": { - "line": 167, - "col": 29 - } - }, - "pc": 0 + "source": 159, + "pc": [ + 555 + ] }, { "teal": 582, - "source": { - "start": { - "line": 167, - "col": 9 - }, - "end": { - "line": 167, - "col": 29 - } - }, - "pc": 0 + "source": 159, + "pc": [ + 556 + ] }, { "teal": 583, - "source": { - "start": { - "line": 167, - "col": 9 - }, - "end": { - "line": 167, - "col": 29 - } - }, - "pc": 0 - }, - { - "teal": 584, - "source": { - "start": { - "line": 154, - "col": 21 - }, - "end": { - "line": 154, - "col": 42 - } - }, - "pc": 0 - }, - { - "teal": 585, - "source": { - "start": { - "line": 154, - "col": 21 - }, - "end": { - "line": 154, - "col": 42 - } - }, - "pc": 0 - }, - { - "teal": 586, - "source": { - "start": { - "line": 154, - "col": 21 - }, - "end": { - "line": 154, - "col": 42 - } - }, - "pc": 0 + "source": 159, + "pc": [ + 557, + 558 + ] + }, + { + "teal": 587, + "source": 160, + "pc": [ + 559, + 560 + ] + }, + { + "teal": 588, + "source": 160, + "pc": [ + 561, + 562 + ] + }, + { + "teal": 589, + "source": 160, + "pc": [ + 563, + 564 + ] }, { "teal": 590, - "source": { - "start": { - "line": 169, - "col": 4 - }, - "end": { - "line": 172, - "col": 6 - } - }, - "pc": 0 + "source": 160, + "pc": [ + 565 + ] }, { "teal": 591, - "source": { - "start": { - "line": 169, - "col": 4 - }, - "end": { - "line": 172, - "col": 6 - } - }, - "pc": 0 - }, - { - "teal": 594, - "source": { - "start": { - "line": 169, - "col": 4 - }, - "end": { - "line": 172, - "col": 6 - } - }, - "pc": 0 - }, - { - "teal": 595, - "source": { - "start": { - "line": 169, - "col": 4 - }, - "end": { - "line": 172, - "col": 6 - } - }, - "pc": 0 - }, - { - "teal": 598, - "source": { - "start": { - "line": 169, - "col": 4 - }, - "end": { - "line": 172, - "col": 6 - } - }, - "pc": 0 - }, - { - "teal": 599, - "source": { - "start": { - "line": 170, - "col": 6 - }, - "end": { - "line": 170, - "col": 67 - } - }, - "pc": 0 + "source": 160, + "pc": [ + 566 + ] + }, + { + "teal": 592, + "source": 160, + "pc": [ + 567, + 568 + ] + }, + { + "teal": 596, + "source": 161, + "pc": [ + 569, + 570 + ] + }, + { + "teal": 597, + "source": 161, + "pc": [ + 571, + 572 + ] + }, + { + "teal": 600, + "source": 159, + "pc": [ + 573 + ] + }, + { + "teal": 601, + "source": 159, + "pc": [ + 574, + 575 + ] }, { "teal": 604, - "source": { - "start": { - "line": 170, - "col": 23 - }, - "end": { - "line": 170, - "col": 67 - } - }, - "pc": 0 - }, - { - "teal": 606, - "source": { - "start": { - "line": 170, - "col": 6 - }, - "end": { - "line": 170, - "col": 67 - } - }, - "pc": 0 - }, - { - "teal": 607, - "source": { - "start": { - "line": 171, - "col": 6 - }, - "end": { - "line": 171, - "col": 31 - } - }, - "pc": 0 - }, - { - "teal": 608, - "source": { - "start": { - "line": 171, - "col": 6 - }, - "end": { - "line": 171, - "col": 31 - } - }, - "pc": 0 + "source": 159, + "pc": [ + 576 + ] + }, + { + "teal": 605, + "source": 143, + "pc": [ + 577 + ] }, { "teal": 610, - "source": { - "start": { - "line": 171, - "col": 16 - }, - "end": { - "line": 171, - "col": 24 - } - }, - "pc": 0 + "source": 168, + "pc": [ + 578, + 579, + 580 + ] }, { "teal": 611, - "source": { - "start": { - "line": 171, - "col": 6 - }, - "end": { - "line": 171, - "col": 31 - } - }, - "pc": 0 - }, - { - "teal": 615, - "source": { - "start": { - "line": 169, - "col": 4 - }, - "end": { - "line": 172, - "col": 6 - } - }, - "pc": 0 - }, - { - "teal": 616, - "source": { - "start": { - "line": 169, - "col": 4 - }, - "end": { - "line": 172, - "col": 6 - } - }, - "pc": 0 - }, - { - "teal": 617, - "source": { - "start": { - "line": 169, - "col": 4 - }, - "end": { - "line": 172, - "col": 6 - } - }, - "pc": 0 + "source": 168, + "pc": [ + 581 + ] + }, + { + "teal": 612, + "source": 168, + "pc": [ + 582 + ] }, { "teal": 618, - "source": { - "start": { - "line": 151, - "col": 2 - }, - "end": { - "line": 173, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 619, - "source": { - "start": { - "line": 178, - "col": 2 - }, - "end": { - "line": 180, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 627, - "source": { - "start": { - "line": 178, - "col": 2 - }, - "end": { - "line": 180, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 629, - "source": { - "start": { - "line": 178, - "col": 2 - }, - "end": { - "line": 180, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 630, - "source": { - "start": { - "line": 179, - "col": 4 - }, - "end": { - "line": 179, - "col": 54 - } - }, - "pc": 0 + "source": 168, + "pc": [ + 583, + 584, + 585 + ] + }, + { + "teal": 622, + "source": 169, + "pc": [ + 586, + 587 + ] + }, + { + "teal": 623, + "source": 169, + "pc": [ + 588, + 589 + ] + }, + { + "teal": 624, + "source": 169, + "pc": [ + 590 + ] + }, + { + "teal": 625, + "source": 169, + "pc": [ + 591 + ] + }, + { + "teal": 626, + "source": 168, + "pc": [ + 592 + ] }, { "teal": 631, - "source": { - "start": { - "line": 179, - "col": 4 - }, - "end": { - "line": 179, - "col": 54 - } - }, - "pc": 0 + "source": 178, + "pc": [ + 593, + 594, + 595 + ] + }, + { + "teal": 632, + "source": 178, + "pc": [ + 596 + ] }, { "teal": 633, - "source": { - "start": { - "line": 179, - "col": 11 - }, - "end": { - "line": 179, - "col": 19 - } - }, - "pc": 0 - }, - { - "teal": 634, - "source": { - "start": { - "line": 179, - "col": 31 - }, - "end": { - "line": 179, - "col": 53 - } - }, - "pc": 0 - }, - { - "teal": 635, - "source": { - "start": { - "line": 179, - "col": 27 - }, - "end": { - "line": 179, - "col": 30 - } - }, - "pc": 0 - }, - { - "teal": 637, - "source": { - "start": { - "line": 179, - "col": 11 - }, - "end": { - "line": 179, - "col": 53 - } - }, - "pc": 0 - }, - { - "teal": 638, - "source": { - "start": { - "line": 178, - "col": 2 - }, - "end": { - "line": 180, - "col": 3 - } - }, - "pc": 0 - }, - { - "teal": 639, - "source": { - "start": { - "line": 188, - "col": 2 - }, - "end": { - "line": 188, - "col": 18 - } - }, - "pc": 0 - }, - { - "teal": 641, - "source": { - "start": { - "line": 188, - "col": 2 - }, - "end": { - "line": 188, - "col": 18 - } - }, - "pc": 0 + "source": 178, + "pc": [ + 597 + ] }, { "teal": 642, - "source": { - "start": { - "line": 188, - "col": 2 - }, - "end": { - "line": 188, - "col": 18 - } - }, - "pc": 0 + "source": 178, + "pc": [ + 598, + 599, + 600 + ] }, { "teal": 643, - "source": { - "start": { - "line": 188, - "col": 2 - }, - "end": { - "line": 188, - "col": 18 - } - }, - "pc": 0 - }, - { - "teal": 644, - "source": { - "start": { - "line": 188, - "col": 2 - }, - "end": { - "line": 188, - "col": 18 - } - }, - "pc": 0 - }, - { - "teal": 645, - "source": { - "start": { - "line": 188, - "col": 2 - }, - "end": { - "line": 188, - "col": 18 - } - }, - "pc": 0 + "source": 178, + "pc": [ + 601 + ] + }, + { + "teal": 646, + "source": 38, + "pc": [ + 602 + ] }, { "teal": 647, - "source": { - "start": { - "line": 188, - "col": 2 - }, - "end": { - "line": 188, - "col": 18 - } - }, - "pc": 0 - }, - { - "teal": 648, - "source": { - "start": { - "line": 188, - "col": 2 - }, - "end": { - "line": 188, - "col": 18 - } - }, - "pc": 0 - }, - { - "teal": 649, - "source": { - "start": { - "line": 188, - "col": 2 - }, - "end": { - "line": 188, - "col": 18 - } - }, - "pc": 0 + "source": 38, + "pc": [ + 603 + ] }, { "teal": 650, - "source": { - "start": { - "line": 188, - "col": 2 - }, - "end": { - "line": 188, - "col": 18 - } - }, - "pc": 0 + "source": 38, + "pc": [ + 604, + 605, + 606, + 607, + 608, + 609 + ] }, { "teal": 651, - "source": { - "start": { - "line": 188, - "col": 2 - }, - "end": { - "line": 188, - "col": 18 - } - }, - "pc": 0 + "source": 38, + "pc": [ + 610, + 611, + 612 + ] }, { "teal": 652, - "source": { - "start": { - "line": 188, - "col": 2 - }, - "end": { - "line": 188, - "col": 18 - } - }, - "pc": 0 - }, - { - "teal": 653, - "source": { - "start": { - "line": 188, - "col": 2 - }, - "end": { - "line": 188, - "col": 18 - } - }, - "pc": 0 - }, - { - "teal": 654, - "source": { - "start": { - "line": 188, - "col": 2 - }, - "end": { - "line": 188, - "col": 18 - } - }, - "pc": 0 + "source": 38, + "pc": [ + 613, + 614, + 615, + 616 + ] }, { "teal": 655, - "source": { - "start": { - "line": 188, - "col": 2 - }, - "end": { - "line": 188, - "col": 18 - } - }, - "pc": 0 - }, - { - "teal": 656, - "source": { - "start": { - "line": 39, - "col": 0 - }, - "end": { - "line": 189, - "col": 1 - } - }, - "pc": 0 + "source": 38, + "errorMessage": "this contract does not implement the given ABI method for create NoOp", + "pc": [ + 617 + ] }, { "teal": 658, - "source": { - "start": { - "line": 39, - "col": 0 - }, - "end": { - "line": 189, - "col": 1 - } - }, - "pc": 0 + "source": 38, + "pc": [ + 618, + 619, + 620, + 621, + 622, + 623 + ] }, { "teal": 659, - "source": { - "start": { - "line": 39, - "col": 0 - }, - "end": { - "line": 189, - "col": 1 - } - }, - "pc": 0 + "source": 38, + "pc": [ + 624, + 625, + 626, + 627, + 628, + 629 + ] }, { "teal": 660, - "source": { - "start": { - "line": 39, - "col": 0 - }, - "end": { - "line": 189, - "col": 1 - } - }, - "pc": 0 + "source": 38, + "pc": [ + 630, + 631, + 632, + 633, + 634, + 635 + ] }, { "teal": 661, - "source": { - "start": { - "line": 39, - "col": 0 - }, - "end": { - "line": 189, - "col": 1 - } - }, - "pc": 0 + "source": 38, + "pc": [ + 636, + 637, + 638, + 639, + 640, + 641 + ] }, { "teal": 662, - "source": { - "start": { - "line": 39, - "col": 0 - }, - "end": { - "line": 189, - "col": 1 - } - }, - "pc": 0 - }, - { - "teal": 1, - "source": { - "start": { - "line": 39, - "col": 0 - }, - "end": { - "line": 189, - "col": 1 - } - }, - "pc": 0 + "source": 38, + "pc": [ + 642, + 643, + 644, + 645, + 646, + 647 + ] + }, + { + "teal": 663, + "source": 38, + "pc": [ + 648, + 649, + 650, + 651, + 652, + 653 + ] + }, + { + "teal": 664, + "source": 38, + "pc": [ + 654, + 655, + 656 + ] + }, + { + "teal": 665, + "source": 38, + "pc": [ + 657, + 658, + 659, + 660, + 661, + 662, + 663, + 664, + 665, + 666, + 667, + 668, + 669, + 670 + ] + }, + { + "teal": 668, + "source": 38, + "errorMessage": "this contract does not implement the given ABI method for call NoOp", + "pc": [ + 671 + ] + }, + { + "teal": 671, + "source": 38, + "pc": [ + 672, + 673, + 674, + 675, + 676, + 677 + ] + }, + { + "teal": 672, + "source": 38, + "pc": [ + 678, + 679, + 680 + ] + }, + { + "teal": 673, + "source": 38, + "pc": [ + 681, + 682, + 683, + 684 + ] + }, + { + "teal": 676, + "source": 38, + "errorMessage": "this contract does not implement the given ABI method for call UpdateApplication", + "pc": [ + 685 + ] } ] \ No newline at end of file diff --git a/reference_contract/__test__/DIDocument.json b/reference_contract/__test__/DIDocument.json index 9f179e9..d8e39b2 100644 --- a/reference_contract/__test__/DIDocument.json +++ b/reference_contract/__test__/DIDocument.json @@ -1,93 +1,19 @@ { - "@context": [ - "https://www.w3.org/ns/did/v1", - "https://w3id.org/security/suites/jws-2020/v1" - ], - "verificationMethod": [ - { - "id": "did:example:123#key-0", - "type": "JsonWebKey2020", - "controller": "did:example:123", - "publicKeyJwk": { - "kty": "OKP", - "crv": "Ed25519", - "x": "VCpo2LMLhn6iWku8MKvSLg2ZAoC-nlOyPVQaO3FxVeQ" - } - }, - { - "id": "did:example:123#key-1", - "type": "JsonWebKey2020", - "controller": "did:example:123", - "publicKeyJwk": { - "kty": "OKP", - "crv": "X25519", - "x": "pE_mG098rdQjY3MKK2D5SUQ6ZOEW3a6Z6T7Z4SgnzCE" - } - }, - { - "id": "did:example:123#key-2", - "type": "JsonWebKey2020", - "controller": "did:example:123", - "publicKeyJwk": { - "kty": "EC", - "crv": "secp256k1", - "x": "Z4Y3NNOxv0J6tCgqOBFnHnaZhJF6LdulT7z8A-2D5_8", - "y": "i5a2NtJoUKXkLm6q8nOEu9WOkso1Ag6FTUT6k_LMnGk" - } - }, - { - "id": "did:example:123#key-3", - "type": "JsonWebKey2020", - "controller": "did:example:123", - "publicKeyJwk": { - "kty": "EC", - "crv": "secp256k1", - "x": "U1V4TVZVMUpUa0ZVU1NBcU9CRm5IbmFaaEpGNkxkdWx", - "y": "i5a2NtJoUKXkLm6q8nOEu9WOkso1Ag6FTUT6k_LMnGk" - } - }, - { - "id": "did:example:123#key-4", - "type": "JsonWebKey2020", - "controller": "did:example:123", - "publicKeyJwk": { - "kty": "EC", - "crv": "P-256", - "x": "Ums5WVgwRkRTVVFnU3k5c2xvZllMbEcwM3NPRW91ZzN", - "y": "nDQW6XZ7b_u2Sy9slofYLlG03sOEoug3I0aAPQ0exs4" - } - }, - { - "id": "did:example:123#key-5", - "type": "JsonWebKey2020", - "controller": "did:example:123", - "publicKeyJwk": { - "kty": "EC", - "crv": "P-384", - "x": "VUZKSlUwMGdpSXplekRwODhzX2N4U1BYdHVYWUZsaXVDR25kZ1U0UXA4bDkxeHpE", - "y": "jq4QoAHKiIzezDp88s_cxSPXtuXYFliuCGndgU4Qp8l91xzD1spCmFIzQgVjqvcP" - } - }, - { - "id": "did:example:123#key-6", - "type": "JsonWebKey2020", - "controller": "did:example:123", - "publicKeyJwk": { - "kty": "EC", - "crv": "P-521", - "x": "VTI5c1lYSmZWMmx1WkhNZ0dQTXhaYkhtSnBEU3UtSXZwdUtpZ0VOMnB6Z1d0U28tLVJ3ZC1uNzhuclduWnplRGMx", - "y": "UW5WNVgwSnBkR052YVc0Z1VqY1B6LVpoZWNaRnliT3FMSUpqVk9sTEVUSDd1UGx5RzBnRW9NV25JWlhoUVZ5cFB5" - } - }, - { - "id": "did:example:123#key-7", - "type": "JsonWebKey2020", - "controller": "did:example:123", - "publicKeyJwk": { - "kty": "RSA", - "e": "AQAB", - "n": "UkhWaGJGOUZRMTlFVWtKSElBdENGV2hlU1F2djFNRXh1NVJMQ01UNGpWazlraEpLdjhKZU1YV2UzYldIYXRqUHNrZGYyZGxhR2tXNVFqdE9uVUtMNzQybXZyNHRDbGRLUzNVTElhVDFoSkluTUhIeGoyZ2N1Yk82ZUVlZ0FDUTRRU3U5TE8wSC1MTV9MM0RzUkFCQjdRamE4SGVjcHl1c3BXMVR1X0RicXhjU253ZW5kYW13TDUyVjE3ZUtobE80dVh3djJIRmx4dWZGSE0wS21DSnVqSUt5QXhqRF9tM3FfX0lpSFVWSEQxdERJRXZMUGhHOUF6c24zajk1ZC1zYU" - } - } - ] - } \ No newline at end of file + "@context": [ + "https://www.w3.org/ns/did/v1", + "https://w3id.org/security/suites/ed25519-2020/v1", + "https://w3id.org/security/suites/x25519-2020/v1" + ], + "id": "did:algo:testnet:app:683630753:98e39ab73670526e13a0ef4a64cca7792bf1d418b9ff8dc44121b1c61dae9526", + "verificationMethod": [ + { + "id": "did:algo:testnet:app:683630753:98e39ab73670526e13a0ef4a64cca7792bf1d418b9ff8dc44121b1c61dae9526#master", + "type": "Ed25519VerificationKey2020", + "controller": "did:algo:testnet:app:683630753:98e39ab73670526e13a0ef4a64cca7792bf1d418b9ff8dc44121b1c61dae9526", + "publicKeyMultibase": "zBHpGLoenrbXcHhsJW5htp8VDpmWgMcCEHJdaEA6rVmxq" + } + ], + "authentication": [ + "did:algo:testnet:app:683630753:98e39ab73670526e13a0ef4a64cca7792bf1d418b9ff8dc44121b1c61dae9526#master" + ] +} diff --git a/reference_contract/package.json b/reference_contract/package.json index 2afa37b..6052e58 100644 --- a/reference_contract/package.json +++ b/reference_contract/package.json @@ -5,7 +5,7 @@ "scripts": { "compile-contract": "tealscript contracts/algo-did.algo.ts contracts/artifacts", "generate-client": "algokitgen generate -a contracts/artifacts/AlgoDID.json -o contracts/clients/AlgoDIDClient.ts", - "build": "npm run compile-contract", + "build": "npm run compile-contract && cp contracts/artifacts/AlgoDID* ../client/internal/contracts", "test": "npm run build && jest", "lint": "eslint . --ext .ts", "fix": "eslint . --ext .ts --fix" From 8f3c4e2c69f3d68c13590226b7a90286f554efea Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Wed, 19 Jun 2024 13:41:46 -0400 Subject: [PATCH 6/9] update README --- reference_contract/README.md | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 reference_contract/README.md diff --git a/reference_contract/README.md b/reference_contract/README.md new file mode 100644 index 0000000..89f9e5b --- /dev/null +++ b/reference_contract/README.md @@ -0,0 +1,15 @@ +# Reference Contract + +This is the reference implementation of the contract that will be used to store the DIDDocuments for `did:algo`. This is the contract that is used by the CLI tool by default when deploying a new contract. + +It should be noted that the `did:algo` spec will work with any contract that implements the ABI interface defined in [the ARC4 JSON description](./contracts/artifacts/AlgoDID.arc4.json) and the `did:algo` [spec](../SPEC.md). + +## Tests + +Tests for the contract can be found at [here](./__test__/algo-did.test.ts). + +## Interacting With Contract + +Golang code for interacting with this contract can be seen [here](../client/internal/main.go). + +TypeScript code for interacting with this contract can be seen [here](./src/index.ts). From 82c48e557d5a950f5cf682998ec18b5e4258b23b Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Wed, 19 Jun 2024 13:53:46 -0400 Subject: [PATCH 7/9] update contract name --- client/internal/contracts.go | 6 +- client/internal/contracts/AlgoDID.abi.json | 143 --- client/internal/contracts/AlgoDID.arc32.json | 214 ---- client/internal/contracts/AlgoDID.json | 223 ---- ...oval.teal => DIDAlgoStorage.approval.teal} | 76 +- .../contracts/DIDAlgoStorage.arc32.json | 214 ++++ .../contracts/DIDAlgoStorage.arc4.json | 2 +- ...t.json => DIDAlgoStorage.arc56_draft.json} | 4 +- ...D.clear.teal => DIDAlgoStorage.clear.teal} | 0 ...c_map.json => DIDAlgoStorage.src_map.json} | 0 reference_contract/README.md | 4 +- ...o-did.test.ts => did-algo-storage.test.ts} | 2 +- .../contracts/artifacts/AlgoDID.abi.json | 143 --- .../contracts/artifacts/AlgoDID.arc32.json | 214 ---- .../contracts/artifacts/AlgoDID.json | 223 ---- ...oval.teal => DIDAlgoStorage.approval.teal} | 76 +- .../artifacts/DIDAlgoStorage.arc32.json | 214 ++++ .../artifacts/DIDAlgoStorage.arc4.json | 2 +- ...t.json => DIDAlgoStorage.arc56_draft.json} | 4 +- ...D.clear.teal => DIDAlgoStorage.clear.teal} | 0 ...c_map.json => DIDAlgoStorage.src_map.json} | 0 .../contracts/clients/AlgoDIDClient.ts | 1047 ----------------- ...o-did.algo.ts => did-algo-storage.algo.ts} | 2 +- reference_contract/package-lock.json | 4 +- reference_contract/package.json | 7 +- reference_contract/src/index.ts | 2 +- 26 files changed, 523 insertions(+), 2303 deletions(-) delete mode 100644 client/internal/contracts/AlgoDID.abi.json delete mode 100644 client/internal/contracts/AlgoDID.arc32.json delete mode 100644 client/internal/contracts/AlgoDID.json rename client/internal/contracts/{AlgoDID.approval.teal => DIDAlgoStorage.approval.teal} (88%) create mode 100644 client/internal/contracts/DIDAlgoStorage.arc32.json rename reference_contract/contracts/artifacts/AlgoDID.arc4.json => client/internal/contracts/DIDAlgoStorage.arc4.json (99%) rename client/internal/contracts/{AlgoDID.arc56_draft.json => DIDAlgoStorage.arc56_draft.json} (75%) rename client/internal/contracts/{AlgoDID.clear.teal => DIDAlgoStorage.clear.teal} (100%) rename client/internal/contracts/{AlgoDID.src_map.json => DIDAlgoStorage.src_map.json} (100%) rename reference_contract/__test__/{algo-did.test.ts => did-algo-storage.test.ts} (98%) delete mode 100644 reference_contract/contracts/artifacts/AlgoDID.abi.json delete mode 100644 reference_contract/contracts/artifacts/AlgoDID.arc32.json delete mode 100644 reference_contract/contracts/artifacts/AlgoDID.json rename reference_contract/contracts/artifacts/{AlgoDID.approval.teal => DIDAlgoStorage.approval.teal} (88%) create mode 100644 reference_contract/contracts/artifacts/DIDAlgoStorage.arc32.json rename client/internal/contracts/AlgoDID.arc4.json => reference_contract/contracts/artifacts/DIDAlgoStorage.arc4.json (99%) rename reference_contract/contracts/artifacts/{AlgoDID.arc56_draft.json => DIDAlgoStorage.arc56_draft.json} (75%) rename reference_contract/contracts/artifacts/{AlgoDID.clear.teal => DIDAlgoStorage.clear.teal} (100%) rename reference_contract/contracts/artifacts/{AlgoDID.src_map.json => DIDAlgoStorage.src_map.json} (100%) delete mode 100644 reference_contract/contracts/clients/AlgoDIDClient.ts rename reference_contract/contracts/{algo-did.algo.ts => did-algo-storage.algo.ts} (99%) diff --git a/client/internal/contracts.go b/client/internal/contracts.go index 934e73b..3440f49 100644 --- a/client/internal/contracts.go +++ b/client/internal/contracts.go @@ -28,7 +28,7 @@ func init() { StorageContracts, _ = fs.Sub(dist, "contracts") // load approval program - approvalFile, err := StorageContracts.Open("AlgoDID.approval.teal") + approvalFile, err := StorageContracts.Open("DIDAlgoStorage.approval.teal") if err != nil { panic(err) } @@ -39,7 +39,7 @@ func init() { _ = approvalFile.Close() // load clear program - clearFile, err := StorageContracts.Open("AlgoDID.clear.teal") + clearFile, err := StorageContracts.Open("DIDAlgoStorage.clear.teal") if err != nil { panic(err) } @@ -52,7 +52,7 @@ func init() { // LoadContract loads the AlgoDID smart contract ABI from JSON file. func LoadContract() *abi.Contract { - abiFile, _ := StorageContracts.Open("AlgoDID.abi.json") + abiFile, _ := StorageContracts.Open("DIDAlgoStorage.arc4.json") abiContents, _ := io.ReadAll(abiFile) contract := &abi.Contract{} _ = json.Unmarshal(abiContents, contract) diff --git a/client/internal/contracts/AlgoDID.abi.json b/client/internal/contracts/AlgoDID.abi.json deleted file mode 100644 index a62273e..0000000 --- a/client/internal/contracts/AlgoDID.abi.json +++ /dev/null @@ -1,143 +0,0 @@ -{ - "name": "AlgoDID", - "desc": "", - "methods": [ - { - "name": "startUpload", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The pubkey of the DID" - }, - { - "name": "numBoxes", - "type": "uint64", - "desc": "The number of boxes that the data will take up" - }, - { - "name": "endBoxSize", - "type": "uint64", - "desc": "The size of the last box" - }, - { - "name": "mbrPayment", - "type": "pay", - "desc": "Payment from the uploader to cover the box MBR" - } - ], - "desc": "Allocate boxes to begin data upload process", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "upload", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The pubkey of the DID" - }, - { - "name": "boxIndex", - "type": "uint64", - "desc": "The index of the box to upload the given chunk of data to" - }, - { - "name": "offset", - "type": "uint64", - "desc": "The offset within the box to start writing the data" - }, - { - "name": "data", - "type": "byte[]", - "desc": "The data to write" - } - ], - "desc": "Upload data to a specific offset in a box", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "finishUpload", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The address of the DID" - } - ], - "desc": "Mark uploading as false", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "startDelete", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The address of the DID" - } - ], - "desc": "Starts the deletion process for the data associated with a DID", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "deleteData", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The address of the DID" - }, - { - "name": "boxIndex", - "type": "uint64", - "desc": "The index of the box to delete" - } - ], - "desc": "Deletes a box of data", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "updateApplication", - "args": [], - "desc": "Allow the contract to be updated by the creator", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "dummy", - "args": [], - "desc": "Dummy function to add extra box references for deleteData.Boxes are 32k, but a single app call can only inlcude enough references to read/write 8kat a time. Thus when a box is deleted, we need to add additional dummy calls with boxreferences to increase the total read/write budget to 32k.", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "createApplication", - "desc": "", - "returns": { - "type": "void", - "desc": "" - }, - "args": [] - } - ] -} \ No newline at end of file diff --git a/client/internal/contracts/AlgoDID.arc32.json b/client/internal/contracts/AlgoDID.arc32.json deleted file mode 100644 index 9d43dc9..0000000 --- a/client/internal/contracts/AlgoDID.arc32.json +++ /dev/null @@ -1,214 +0,0 @@ -{ - "hints": { - "startUpload(address,uint64,uint64,pay)void": { - "call_config": { - "no_op": "CALL" - } - }, - "upload(address,uint64,uint64,byte[])void": { - "call_config": { - "no_op": "CALL" - } - }, - "finishUpload(address)void": { - "call_config": { - "no_op": "CALL" - } - }, - "startDelete(address)void": { - "call_config": { - "no_op": "CALL" - } - }, - "deleteData(address,uint64)void": { - "call_config": { - "no_op": "CALL" - } - }, - "updateApplication()void": { - "call_config": { - "update_application": "CALL" - } - }, - "dummy()void": { - "call_config": { - "no_op": "CALL" - } - }, - "createApplication()void": { - "call_config": { - "no_op": "CREATE" - } - } - }, - "bare_call_config": { - "no_op": "NEVER", - "opt_in": "NEVER", - "close_out": "NEVER", - "update_application": "NEVER", - "delete_application": "NEVER" - }, - "schema": { - "local": { - "declared": {}, - "reserved": {} - }, - "global": { - "declared": { - "currentIndex": { - "type": "uint64", - "key": "currentIndex" - } - }, - "reserved": {} - } - }, - "state": { - "global": { - "num_byte_slices": 0, - "num_uints": 1 - }, - "local": { - "num_byte_slices": 0, - "num_uints": 0 - } - }, - "source": { - "approval": "#pragma version 10

// This TEAL was generated by TEALScript v0.96.0
// https://github.com/algorandfoundation/TEALScript

// This contract is compliant with and/or implements the following ARCs: [ ARC4 ]

// The following ten lines of TEAL handle initial program flow
// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed
// Here, action refers to the OnComplete in combination with whether the app is being created or called
// Every possible action for this contract is represented in the switch statement
// If the action is not implemented in the contract, its respective branch will be "*NOT_IMPLEMENTED" which just contains "err"
txn ApplicationID
!
int 6
*
txn OnCompletion
+
switch *call_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *call_UpdateApplication *NOT_IMPLEMENTED *create_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED

*NOT_IMPLEMENTED:
	// The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?
	err

// startUpload(address,uint64,uint64,pay)void
*abi_route_startUpload:
	// mbrPayment: pay
	txn GroupIndex
	int 1
	-
	dup
	gtxns TypeEnum
	int pay
	==

	// argument 0 (mbrPayment) for startUpload must be a pay transaction
	assert

	// endBoxSize: uint64
	txna ApplicationArgs 3
	btoi

	// numBoxes: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 3 (pubKey) for startUpload must be a address
	assert

	// execute startUpload(address,uint64,uint64,pay)void
	callsub startUpload
	int 1
	return

// startUpload(pubKey: Address, numBoxes: uint64, endBoxSize: uint64, mbrPayment: PayTxn): void
//
//
// Allocate boxes to begin data upload process
//
// @param pubKey The pubkey of the DID
// @param numBoxes The number of boxes that the data will take up
// @param endBoxSize The size of the last box
// @param mbrPayment Payment from the uploader to cover the box MBR
startUpload:
	proto 4 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x
	dupn 3

	// contracts/algo-did.algo.ts:63
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:65
	// startBox = this.currentIndex.value
	byte 0x63757272656e74496e646578 // "currentIndex"
	app_global_get
	frame_bury 0 // startBox: uint64

	// contracts/algo-did.algo.ts:66
	// endBox = startBox + numBoxes - 1
	frame_dig 0 // startBox: uint64
	frame_dig -2 // numBoxes: uint64
	+
	int 1
	-
	frame_bury 1 // endBox: uint64

	// contracts/algo-did.algo.ts:68
	// metadata: Metadata = {
	//       start: startBox, end: endBox, status: UPLOADING, endSize: endBoxSize, lastDeleted: 0,
	//     }
	frame_dig 0 // startBox: uint64
	itob
	frame_dig 1 // endBox: uint64
	itob
	concat
	byte 0x00
	concat
	frame_dig -3 // endBoxSize: uint64
	itob
	concat
	byte 0x0000000000000000
	concat
	frame_bury 2 // metadata: Metadata

	// contracts/algo-did.algo.ts:72
	// assert(!this.metadata(pubKey).exists)
	frame_dig -1 // pubKey: Address
	box_len
	swap
	pop
	!
	assert

	// contracts/algo-did.algo.ts:74
	// this.metadata(pubKey).value = metadata
	frame_dig -1 // pubKey: Address
	frame_dig 2 // metadata: Metadata
	box_put

	// contracts/algo-did.algo.ts:76
	// this.currentIndex.value = endBox + 1
	byte 0x63757272656e74496e646578 // "currentIndex"
	frame_dig 1 // endBox: uint64
	int 1
	+
	app_global_put

	// contracts/algo-did.algo.ts:78
	// totalCost = numBoxes * COST_PER_BOX // cost of data boxes
	//     + (numBoxes - 1) * MAX_BOX_SIZE * COST_PER_BYTE // cost of data
	//     + numBoxes * 8 * COST_PER_BYTE // cost of data keys
	//     + endBoxSize * COST_PER_BYTE // cost of last data box
	//     + COST_PER_BOX + (8 + 8 + 1 + 8 + 32 + 8) * COST_PER_BYTE
	frame_dig -2 // numBoxes: uint64
	int 2500
	*
	frame_dig -2 // numBoxes: uint64
	int 1
	-
	int 32768
	*
	int 400
	*
	+
	frame_dig -2 // numBoxes: uint64
	int 8
	*
	int 400
	*
	+
	frame_dig -3 // endBoxSize: uint64
	int 400
	*
	+
	int 2500
	+
	int 26000
	+
	frame_bury 3 // totalCost: uint64

	// contracts/algo-did.algo.ts:84
	// assert(mbrPayment.amount === totalCost)
	frame_dig -4 // mbrPayment: PayTxn
	gtxns Amount
	frame_dig 3 // totalCost: uint64
	==
	assert

	// contracts/algo-did.algo.ts:85
	// assert(mbrPayment.receiver === this.app.address)
	frame_dig -4 // mbrPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==
	assert
	retsub

// upload(address,uint64,uint64,byte[])void
*abi_route_upload:
	// data: byte[]
	txna ApplicationArgs 4
	extract 2 0

	// offset: uint64
	txna ApplicationArgs 3
	btoi

	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 3 (pubKey) for upload must be a address
	assert

	// execute upload(address,uint64,uint64,byte[])void
	callsub upload
	int 1
	return

// upload(pubKey: Address, boxIndex: uint64, offset: uint64, data: bytes): void
//
//
// Upload data to a specific offset in a box
//
// @param pubKey The pubkey of the DID
// @param boxIndex The index of the box to upload the given chunk of data to
// @param offset The offset within the box to start writing the data
// @param data The data to write
upload:
	proto 4 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x

	// contracts/algo-did.algo.ts:98
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:100
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: Address
	frame_bury 0 // storage key//metadata

	// contracts/algo-did.algo.ts:101
	// assert(metadata.status === UPLOADING)
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	int 1
	box_extract
	btoi
	int 0
	==
	assert

	// contracts/algo-did.algo.ts:102
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -1 // pubKey: Address
	int 0
	int 8
	box_extract
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz *skip_and0
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	<=
	&&

*skip_and0:
	assert

	// *if0_condition
	// contracts/algo-did.algo.ts:104
	// offset === 0
	frame_dig -3 // offset: uint64
	int 0
	==
	bz *if0_end

	// *if0_consequent
	// contracts/algo-did.algo.ts:105
	// this.dataBoxes(boxIndex).create(boxIndex === metadata.end ? metadata.endSize : MAX_BOX_SIZE)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	==
	bz *ternary0_false
	frame_dig -1 // pubKey: Address
	int 17 // headOffset
	int 8
	box_extract
	btoi
	b *ternary0_end

*ternary0_false:
	int 32768

*ternary0_end:
	box_create
	pop

*if0_end:
	// contracts/algo-did.algo.ts:108
	// this.dataBoxes(boxIndex).replace(offset, data)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -3 // offset: uint64
	frame_dig -4 // data: bytes
	box_replace
	retsub

// finishUpload(address)void
*abi_route_finishUpload:
	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 0 (pubKey) for finishUpload must be a address
	assert

	// execute finishUpload(address)void
	callsub finishUpload
	int 1
	return

// finishUpload(pubKey: Address): void
//
//
// Mark uploading as false
//
// @param pubKey The address of the DID
finishUpload:
	proto 1 0

	// contracts/algo-did.algo.ts:118
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:120
	// this.metadata(pubKey).value.status = READY
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	byte 0x01
	box_replace
	retsub

// startDelete(address)void
*abi_route_startDelete:
	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 0 (pubKey) for startDelete must be a address
	assert

	// execute startDelete(address)void
	callsub startDelete
	int 1
	return

// startDelete(pubKey: Address): void
//
// Starts the deletion process for the data associated with a DID
//
// @param pubKey The address of the DID
startDelete:
	proto 1 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x

	// contracts/algo-did.algo.ts:129
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:131
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: Address
	frame_bury 0 // storage key//metadata

	// contracts/algo-did.algo.ts:132
	// assert(metadata.status === READY)
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	int 1
	box_extract
	btoi
	int 1
	==
	assert

	// contracts/algo-did.algo.ts:134
	// metadata.status = DELETING
	frame_dig 0 // storage key//metadata
	int 16 // headOffset
	byte 0x02
	box_replace
	retsub

// deleteData(address,uint64)void
*abi_route_deleteData:
	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 1 (pubKey) for deleteData must be a address
	assert

	// execute deleteData(address,uint64)void
	callsub deleteData
	int 1
	return

// deleteData(pubKey: Address, boxIndex: uint64): void
//
// Deletes a box of data
//
// @param pubKey The address of the DID
// @param boxIndex The index of the box to delete
deleteData:
	proto 2 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x
	dup

	// contracts/algo-did.algo.ts:144
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:146
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: Address
	frame_bury 0 // storage key//metadata

	// contracts/algo-did.algo.ts:147
	// assert(metadata.status === DELETING)
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	int 1
	box_extract
	btoi
	int 2
	==
	assert

	// contracts/algo-did.algo.ts:148
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -1 // pubKey: Address
	int 0
	int 8
	box_extract
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz *skip_and1
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	<=
	&&

*skip_and1:
	assert

	// *if1_condition
	// contracts/algo-did.algo.ts:150
	// boxIndex !== metadata.start
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 0
	int 8
	box_extract
	btoi
	!=
	bz *if1_end

	// *if1_consequent
	// contracts/algo-did.algo.ts:150
	// assert(metadata.lastDeleted === boxIndex - 1)
	frame_dig -1 // pubKey: Address
	int 25 // headOffset
	int 8
	box_extract
	btoi
	frame_dig -2 // boxIndex: uint64
	int 1
	-
	==
	assert

*if1_end:
	// contracts/algo-did.algo.ts:152
	// preMBR = globals.currentApplicationAddress.minBalance
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	pop
	frame_bury 1 // preMBR: uint64

	// contracts/algo-did.algo.ts:154
	// this.dataBoxes(boxIndex).delete()
	frame_dig -2 // boxIndex: uint64
	itob
	box_del

	// *if2_condition
	// contracts/algo-did.algo.ts:156
	// boxIndex === metadata.end
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	==
	bz *if2_else

	// *if2_consequent
	// contracts/algo-did.algo.ts:156
	// this.metadata(pubKey).delete()
	frame_dig -1 // pubKey: Address
	box_del
	b *if2_end

*if2_else:
	// contracts/algo-did.algo.ts:157
	// metadata.lastDeleted = boxIndex
	int 25 // headOffset
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig 0 // storage key//metadata
	cover 2
	box_replace

*if2_end:
	// contracts/algo-did.algo.ts:159
	// sendPayment({
	//       amount: preMBR - globals.currentApplicationAddress.minBalance,
	//       receiver: this.txn.sender,
	//     })
	itxn_begin
	int pay
	itxn_field TypeEnum

	// contracts/algo-did.algo.ts:160
	// amount: preMBR - globals.currentApplicationAddress.minBalance
	frame_dig 1 // preMBR: uint64
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	pop
	-
	itxn_field Amount

	// contracts/algo-did.algo.ts:161
	// receiver: this.txn.sender
	txn Sender
	itxn_field Receiver

	// Fee field not set, defaulting to 0
	int 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// updateApplication()void
*abi_route_updateApplication:
	// execute updateApplication()void
	callsub updateApplication
	int 1
	return

// updateApplication(): void
//
// Allow the contract to be updated by the creator
updateApplication:
	proto 0 0

	// contracts/algo-did.algo.ts:169
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert
	retsub

// dummy()void
*abi_route_dummy:
	// execute dummy()void
	callsub dummy
	int 1
	return

// dummy(): void
//
// Dummy function to add extra box references for deleteData.
// Boxes are 32k, but a single app call can only inlcude enough references to read/write 8k
// at a time. Thus when a box is deleted, we need to add additional dummy calls with box
// references to increase the total read/write budget to 32k.
dummy:
	proto 0 0
	retsub

*abi_route_createApplication:
	int 1
	return

*create_NoOp:
	method "createApplication()void"
	txna ApplicationArgs 0
	match *abi_route_createApplication

	// this contract does not implement the given ABI method for create NoOp
	err

*call_NoOp:
	method "startUpload(address,uint64,uint64,pay)void"
	method "upload(address,uint64,uint64,byte[])void"
	method "finishUpload(address)void"
	method "startDelete(address)void"
	method "deleteData(address,uint64)void"
	method "dummy()void"
	txna ApplicationArgs 0
	match *abi_route_startUpload *abi_route_upload *abi_route_finishUpload *abi_route_startDelete *abi_route_deleteData *abi_route_dummy

	// this contract does not implement the given ABI method for call NoOp
	err

*call_UpdateApplication:
	method "updateApplication()void"
	txna ApplicationArgs 0
	match *abi_route_updateApplication

	// this contract does not implement the given ABI method for call UpdateApplication
	err", - "clear": "I3ByYWdtYSB2ZXJzaW9uIDEw" - }, - "contract": { - "name": "AlgoDID", - "desc": "", - "methods": [ - { - "name": "startUpload", - "desc": "Allocate boxes to begin data upload process", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The pubkey of the DID" - }, - { - "name": "numBoxes", - "type": "uint64", - "desc": "The number of boxes that the data will take up" - }, - { - "name": "endBoxSize", - "type": "uint64", - "desc": "The size of the last box" - }, - { - "name": "mbrPayment", - "type": "pay", - "desc": "Payment from the uploader to cover the box MBR" - } - ], - "returns": { - "type": "void" - } - }, - { - "name": "upload", - "desc": "Upload data to a specific offset in a box", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The pubkey of the DID" - }, - { - "name": "boxIndex", - "type": "uint64", - "desc": "The index of the box to upload the given chunk of data to" - }, - { - "name": "offset", - "type": "uint64", - "desc": "The offset within the box to start writing the data" - }, - { - "name": "data", - "type": "byte[]", - "desc": "The data to write" - } - ], - "returns": { - "type": "void" - } - }, - { - "name": "finishUpload", - "desc": "Mark uploading as false", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The address of the DID" - } - ], - "returns": { - "type": "void" - } - }, - { - "name": "startDelete", - "desc": "Starts the deletion process for the data associated with a DID", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The address of the DID" - } - ], - "returns": { - "type": "void" - } - }, - { - "name": "deleteData", - "desc": "Deletes a box of data", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The address of the DID" - }, - { - "name": "boxIndex", - "type": "uint64", - "desc": "The index of the box to delete" - } - ], - "returns": { - "type": "void" - } - }, - { - "name": "updateApplication", - "desc": "Allow the contract to be updated by the creator", - "args": [], - "returns": { - "type": "void" - } - }, - { - "name": "dummy", - "desc": "Dummy function to add extra box references for deleteData.Boxes are 32k, but a single app call can only inlcude enough references to read/write 8kat a time. Thus when a box is deleted, we need to add additional dummy calls with boxreferences to increase the total read/write budget to 32k.", - "args": [], - "returns": { - "type": "void" - } - }, - { - "name": "createApplication", - "args": [], - "returns": { - "type": "void" - } - } - ] - } -} \ No newline at end of file diff --git a/client/internal/contracts/AlgoDID.json b/client/internal/contracts/AlgoDID.json deleted file mode 100644 index a3317c5..0000000 --- a/client/internal/contracts/AlgoDID.json +++ /dev/null @@ -1,223 +0,0 @@ -{ - "hints": { - "startUpload(address,uint64,uint64,pay)void": { - "call_config": { - "no_op": "CALL" - } - }, - "upload(address,uint64,uint64,byte[])void": { - "call_config": { - "no_op": "CALL" - } - }, - "finishUpload(address)void": { - "call_config": { - "no_op": "CALL" - } - }, - "startDelete(address)void": { - "call_config": { - "no_op": "CALL" - } - }, - "deleteData(address,uint64)void": { - "call_config": { - "no_op": "CALL" - } - }, - "updateApplication()void": { - "call_config": { - "update_application": "CALL" - } - }, - "dummy()void": { - "call_config": { - "no_op": "CALL" - } - }, - "createApplication()void": { - "call_config": { - "no_op": "CREATE" - } - } - }, - "bare_call_config": { - "no_op": "NEVER", - "opt_in": "NEVER", - "close_out": "NEVER", - "update_application": "NEVER", - "delete_application": "NEVER" - }, - "schema": { - "local": { - "declared": {}, - "reserved": {} - }, - "global": { - "declared": { - "currentIndex": { - "type": "uint64", - "key": "currentIndex" - } - }, - "reserved": {} - } - }, - "state": { - "global": { - "num_byte_slices": 0, - "num_uints": 1 - }, - "local": { - "num_byte_slices": 0, - "num_uints": 0 - } - }, - "source": { - "approval": "#pragma version 9

// This TEAL was generated by TEALScript v0.51.1
// https://github.com/algorand-devrel/TEALScript

// This contract is compliant with and/or implements the following ARCs: [ ARC4 ]

// The following ten lines of TEAL handle initial program flow
// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed
// Here, action refers to the OnComplete in combination with whether the app is being created or called
// Every possible action for this contract is represented in the switch statement
// If the action is not implmented in the contract, its repsective branch will be "NOT_IMPLMENTED" which just contains "err"
txn ApplicationID
int 0
>
int 6
*
txn OnCompletion
+
switch create_NoOp NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED call_NoOp NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED call_UpdateApplication

NOT_IMPLEMENTED:
	err

// startUpload(pay,uint64,uint64,address)void
//
// 
// Allocate boxes to begin data upload process
// 
// @param pubKey The pubkey of the DID
// @param numBoxes The number of boxes that the data will take up
// @param endBoxSize The size of the last box
// @param mbrPayment Payment from the uploader to cover the box MBR
abi_route_startUpload:
	byte 0x; dupn 3 // push empty bytes to fill the stack frame for this subroutine's local variables

	// mbrPayment: pay
	txn GroupIndex
	int 1
	-
	dup
	gtxns TypeEnum
	int pay
	==
	assert

	// endBoxSize: uint64
	txna ApplicationArgs 3
	btoi

	// numBoxes: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute startUpload(pay,uint64,uint64,address)void
	callsub startUpload
	int 1
	return

startUpload:
	proto 8 0

	// contracts/algo-did.algo.ts:64
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:66
	// startBox = this.currentIndex.value
	byte 0x63757272656e74496e646578 // "currentIndex"
	app_global_get
	frame_bury -5 // startBox: uint64

	// contracts/algo-did.algo.ts:67
	// endBox = startBox + numBoxes - 1
	frame_dig -5 // startBox: uint64
	frame_dig -2 // numBoxes: uint64
	+
	int 1
	-
	frame_bury -6 // endBox: uint64

	// contracts/algo-did.algo.ts:69
	// metadata: Metadata = {
	//       start: startBox, end: endBox, status: UPLOADING, endSize: endBoxSize, lastDeleted: 0,
	//     }
	frame_dig -5 // startBox: uint64
	itob
	frame_dig -6 // endBox: uint64
	itob
	concat
	byte 0x00
	byte 0x00
	bitlen
	int 8
	<=
	assert
	byte 0xFF
	b&
	concat
	frame_dig -3 // endBoxSize: uint64
	itob
	concat
	byte 0x0000000000000000
	concat
	frame_bury -7 // metadata: Metadata

	// contracts/algo-did.algo.ts:73
	// assert(!this.metadata(pubKey).exists)
	frame_dig -1 // pubKey: address
	box_len
	swap
	pop
	!
	assert

	// contracts/algo-did.algo.ts:75
	// this.metadata(pubKey).value = metadata
	frame_dig -1 // pubKey: address
	frame_dig -7 // metadata: Metadata
	box_put

	// contracts/algo-did.algo.ts:77
	// this.currentIndex.value = endBox + 1
	byte 0x63757272656e74496e646578 // "currentIndex"
	frame_dig -6 // endBox: uint64
	int 1
	+
	app_global_put

	// contracts/algo-did.algo.ts:79
	// totalCost = numBoxes * COST_PER_BOX // cost of data boxes
	//     + (numBoxes - 1) * MAX_BOX_SIZE * COST_PER_BYTE // cost of data
	//     + numBoxes * 8 * COST_PER_BYTE // cost of data keys
	//     + endBoxSize * COST_PER_BYTE // cost of last data box
	//     + COST_PER_BOX + (8 + 8 + 1 + 8 + 32 + 8) * COST_PER_BYTE
	frame_dig -2 // numBoxes: uint64
	int 2500
	*
	frame_dig -2 // numBoxes: uint64
	int 1
	-
	int 32768
	*
	int 400
	*
	+
	frame_dig -2 // numBoxes: uint64
	int 8
	*
	int 400
	*
	+
	frame_dig -3 // endBoxSize: uint64
	int 400
	*
	+
	int 2500
	+
	int 26000
	+
	frame_bury -8 // totalCost: uint64

	// contracts/algo-did.algo.ts:85
	// assert(mbrPayment.amount === totalCost)
	frame_dig -4 // mbrPayment: pay
	gtxns Amount
	frame_dig -8 // totalCost: uint64
	==
	assert

	// contracts/algo-did.algo.ts:86
	// assert(mbrPayment.receiver === this.app.address)
	frame_dig -4 // mbrPayment: pay
	gtxns Receiver
	global CurrentApplicationAddress
	==
	assert
	retsub

// upload(bytes,uint64,uint64,address)void
//
// 
// Upload data to a specific offset in a box
// 
// @param pubKey The pubkey of the DID
// @param boxIndex The index of the box to upload the given chunk of data to
// @param offset The offset within the box to start writing the data
// @param data The data to write
abi_route_upload:
	byte 0x // push empty bytes to fill the stack frame for this subroutine's local variables

	// data: byte[]
	txna ApplicationArgs 4
	extract 2 0

	// offset: uint64
	txna ApplicationArgs 3
	btoi

	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute upload(bytes,uint64,uint64,address)void
	callsub upload
	int 1
	return

upload:
	proto 5 0

	// contracts/algo-did.algo.ts:99
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:101
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: address
	frame_bury -5 // storage key//metadata

	// contracts/algo-did.algo.ts:102
	// assert(metadata.status === UPLOADING)
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 16 1
	byte 0x0000000000000000
	b==
	assert

	// contracts/algo-did.algo.ts:103
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 0 8
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz skip_and0
	frame_dig -2 // boxIndex: uint64
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 8 8
	btoi
	<=
	&&

skip_and0:
	assert

	// if0_condition
	// contracts/algo-did.algo.ts:105
	// offset === 0
	frame_dig -3 // offset: uint64
	int 0
	==
	bz if0_end

	// if0_consequent
	// contracts/algo-did.algo.ts:106
	// this.dataBoxes(boxIndex).create(boxIndex === metadata.end ? metadata.endSize : MAX_BOX_SIZE)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -2 // boxIndex: uint64
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 8 8
	btoi
	==
	bz ternary0_false
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 17 8
	btoi
	b ternary0_end

ternary0_false:
	int 32768

ternary0_end:
	box_create

if0_end:
	// contracts/algo-did.algo.ts:109
	// this.dataBoxes(boxIndex).replace(offset, data)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -3 // offset: uint64
	frame_dig -4 // data: bytes
	box_replace
	retsub

// finishUpload(address)void
//
// 
// Mark uploading as false
// 
// @param pubKey The address of the DID
abi_route_finishUpload:
	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute finishUpload(address)void
	callsub finishUpload
	int 1
	return

finishUpload:
	proto 1 0

	// contracts/algo-did.algo.ts:119
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:121
	// this.metadata(pubKey).value.status = READY
	frame_dig -1 // pubKey: address
	int 16
	byte 0x01
	box_replace
	retsub

// startDelete(address)void
//
// Starts the deletion process for the data associated with a DID
// 
// @param pubKey The address of the DID
abi_route_startDelete:
	byte 0x // push empty bytes to fill the stack frame for this subroutine's local variables

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute startDelete(address)void
	callsub startDelete
	int 1
	return

startDelete:
	proto 2 0

	// contracts/algo-did.algo.ts:130
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:132
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: address
	frame_bury -2 // storage key//metadata

	// contracts/algo-did.algo.ts:133
	// assert(metadata.status === READY)
	frame_dig -2 // storage key//metadata
	box_get
	assert
	extract 16 1
	byte 0x0000000000000001
	b==
	assert

	// contracts/algo-did.algo.ts:135
	// metadata.status = DELETING
	frame_dig -2 // storage key//metadata
	box_get
	assert
	byte 0x02
	replace2 16
	frame_dig -2 // storage key//metadata
	swap
	box_put
	retsub

// deleteData(uint64,address)void
//
// Deletes a box of data
// 
// @param pubKey The address of the DID
// @param boxIndex The index of the box to delete
abi_route_deleteData:
	byte 0x; dup // push empty bytes to fill the stack frame for this subroutine's local variables

	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute deleteData(uint64,address)void
	callsub deleteData
	int 1
	return

deleteData:
	proto 4 0

	// contracts/algo-did.algo.ts:145
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:147
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: address
	frame_bury -3 // storage key//metadata

	// contracts/algo-did.algo.ts:148
	// assert(metadata.status === DELETING)
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 16 1
	byte 0x0000000000000002
	b==
	assert

	// contracts/algo-did.algo.ts:149
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 0 8
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz skip_and1
	frame_dig -2 // boxIndex: uint64
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 8 8
	btoi
	<=
	&&

skip_and1:
	assert

	// if1_condition
	// contracts/algo-did.algo.ts:151
	// boxIndex !== metadata.start
	frame_dig -2 // boxIndex: uint64
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 0 8
	btoi
	!=
	bz if1_end

	// if1_consequent
	// contracts/algo-did.algo.ts:151
	// assert(metadata.lastDeleted === boxIndex - 1)
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 25 8
	btoi
	frame_dig -2 // boxIndex: uint64
	int 1
	-
	==
	assert

if1_end:
	// contracts/algo-did.algo.ts:153
	// preMBR = globals.currentApplicationAddress.minBalance
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	assert
	frame_bury -4 // preMBR: uint64

	// contracts/algo-did.algo.ts:155
	// this.dataBoxes(boxIndex).delete()
	frame_dig -2 // boxIndex: uint64
	itob
	box_del

	// if2_condition
	// contracts/algo-did.algo.ts:157
	// boxIndex === metadata.end
	frame_dig -2 // boxIndex: uint64
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 8 8
	btoi
	==
	bz if2_else

	// if2_consequent
	// contracts/algo-did.algo.ts:157
	// this.metadata(pubKey).delete()
	frame_dig -1 // pubKey: address
	box_del
	b if2_end

if2_else:
	// contracts/algo-did.algo.ts:158
	// metadata.lastDeleted = boxIndex
	frame_dig -3 // storage key//metadata
	box_get
	assert
	frame_dig -2 // boxIndex: uint64
	itob
	replace2 25
	frame_dig -3 // storage key//metadata
	swap
	box_put

if2_end:
	// contracts/algo-did.algo.ts:160
	// sendPayment({
	//       amount: preMBR - globals.currentApplicationAddress.minBalance,
	//       receiver: this.txn.sender,
	//     })
	itxn_begin
	int pay
	itxn_field TypeEnum

	// contracts/algo-did.algo.ts:161
	// amount: preMBR - globals.currentApplicationAddress.minBalance
	frame_dig -4 // preMBR: uint64
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	assert
	-
	itxn_field Amount

	// contracts/algo-did.algo.ts:162
	// receiver: this.txn.sender
	txn Sender
	itxn_field Receiver

	// Fee field not set, defaulting to 0
	int 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// updateApplication()void
//
// Allow the contract to be updated by the creator
abi_route_updateApplication:
	// execute updateApplication()void
	callsub updateApplication
	int 1
	return

updateApplication:
	proto 0 0

	// contracts/algo-did.algo.ts:170
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert
	retsub

// dummy()void
//
// Dummy function to add extra box references for deleteData.
// Boxes are 32k, but a single app call can only inlcude enough references to read/write 8k
// at a time. Thus when a box is deleted, we need to add additional dummy calls with box
// references to increase the total read/write budget to 32k.
abi_route_dummy:
	// execute dummy()void
	callsub dummy
	int 1
	return

dummy:
	proto 0 0
	retsub

abi_route_createApplication:
	int 1
	return

create_NoOp:
	method "createApplication()void"
	txna ApplicationArgs 0
	match abi_route_createApplication
	err

call_NoOp:
	method "startUpload(address,uint64,uint64,pay)void"
	method "upload(address,uint64,uint64,byte[])void"
	method "finishUpload(address)void"
	method "startDelete(address)void"
	method "deleteData(address,uint64)void"
	method "dummy()void"
	txna ApplicationArgs 0
	match abi_route_startUpload abi_route_upload abi_route_finishUpload abi_route_startDelete abi_route_deleteData abi_route_dummy
	err

call_UpdateApplication:
	method "updateApplication()void"
	txna ApplicationArgs 0
	match abi_route_updateApplication
	err", - "clear": "I3ByYWdtYSB2ZXJzaW9uIDkKaW50IDE=" - }, - "contract": { - "name": "AlgoDID", - "desc": "", - "methods": [ - { - "name": "startUpload", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The pubkey of the DID" - }, - { - "name": "numBoxes", - "type": "uint64", - "desc": "The number of boxes that the data will take up" - }, - { - "name": "endBoxSize", - "type": "uint64", - "desc": "The size of the last box" - }, - { - "name": "mbrPayment", - "type": "pay", - "desc": "Payment from the uploader to cover the box MBR" - } - ], - "desc": "Allocate boxes to begin data upload process", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "upload", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The pubkey of the DID" - }, - { - "name": "boxIndex", - "type": "uint64", - "desc": "The index of the box to upload the given chunk of data to" - }, - { - "name": "offset", - "type": "uint64", - "desc": "The offset within the box to start writing the data" - }, - { - "name": "data", - "type": "byte[]", - "desc": "The data to write" - } - ], - "desc": "Upload data to a specific offset in a box", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "finishUpload", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The address of the DID" - } - ], - "desc": "Mark uploading as false", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "startDelete", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The address of the DID" - } - ], - "desc": "Starts the deletion process for the data associated with a DID", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "deleteData", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The address of the DID" - }, - { - "name": "boxIndex", - "type": "uint64", - "desc": "The index of the box to delete" - } - ], - "desc": "Deletes a box of data", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "updateApplication", - "args": [], - "desc": "Allow the contract to be updated by the creator", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "dummy", - "args": [], - "desc": "Dummy function to add extra box references for deleteData.Boxes are 32k, but a single app call can only inlcude enough references to read/write 8kat a time. Thus when a box is deleted, we need to add additional dummy calls with boxreferences to increase the total read/write budget to 32k.", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "createApplication", - "desc": "", - "returns": { - "type": "void", - "desc": "" - }, - "args": [] - } - ] - } -} \ No newline at end of file diff --git a/client/internal/contracts/AlgoDID.approval.teal b/client/internal/contracts/DIDAlgoStorage.approval.teal similarity index 88% rename from client/internal/contracts/AlgoDID.approval.teal rename to client/internal/contracts/DIDAlgoStorage.approval.teal index a9cdc96..186e5cc 100644 --- a/client/internal/contracts/AlgoDID.approval.teal +++ b/client/internal/contracts/DIDAlgoStorage.approval.teal @@ -75,20 +75,20 @@ startUpload: byte 0x dupn 3 - // contracts/algo-did.algo.ts:63 + // contracts/did-algo-storage.algo.ts:63 // assert(this.txn.sender === globals.creatorAddress) txn Sender global CreatorAddress == assert - // contracts/algo-did.algo.ts:65 + // contracts/did-algo-storage.algo.ts:65 // startBox = this.currentIndex.value byte 0x63757272656e74496e646578 // "currentIndex" app_global_get frame_bury 0 // startBox: uint64 - // contracts/algo-did.algo.ts:66 + // contracts/did-algo-storage.algo.ts:66 // endBox = startBox + numBoxes - 1 frame_dig 0 // startBox: uint64 frame_dig -2 // numBoxes: uint64 @@ -97,7 +97,7 @@ startUpload: - frame_bury 1 // endBox: uint64 - // contracts/algo-did.algo.ts:68 + // contracts/did-algo-storage.algo.ts:68 // metadata: Metadata = { // start: startBox, end: endBox, status: UPLOADING, endSize: endBoxSize, lastDeleted: 0, // } @@ -115,7 +115,7 @@ startUpload: concat frame_bury 2 // metadata: Metadata - // contracts/algo-did.algo.ts:72 + // contracts/did-algo-storage.algo.ts:72 // assert(!this.metadata(pubKey).exists) frame_dig -1 // pubKey: Address box_len @@ -124,13 +124,13 @@ startUpload: ! assert - // contracts/algo-did.algo.ts:74 + // contracts/did-algo-storage.algo.ts:74 // this.metadata(pubKey).value = metadata frame_dig -1 // pubKey: Address frame_dig 2 // metadata: Metadata box_put - // contracts/algo-did.algo.ts:76 + // contracts/did-algo-storage.algo.ts:76 // this.currentIndex.value = endBox + 1 byte 0x63757272656e74496e646578 // "currentIndex" frame_dig 1 // endBox: uint64 @@ -138,7 +138,7 @@ startUpload: + app_global_put - // contracts/algo-did.algo.ts:78 + // contracts/did-algo-storage.algo.ts:78 // totalCost = numBoxes * COST_PER_BOX // cost of data boxes // + (numBoxes - 1) * MAX_BOX_SIZE * COST_PER_BYTE // cost of data // + numBoxes * 8 * COST_PER_BYTE // cost of data keys @@ -171,7 +171,7 @@ startUpload: + frame_bury 3 // totalCost: uint64 - // contracts/algo-did.algo.ts:84 + // contracts/did-algo-storage.algo.ts:84 // assert(mbrPayment.amount === totalCost) frame_dig -4 // mbrPayment: PayTxn gtxns Amount @@ -179,7 +179,7 @@ startUpload: == assert - // contracts/algo-did.algo.ts:85 + // contracts/did-algo-storage.algo.ts:85 // assert(mbrPayment.receiver === this.app.address) frame_dig -4 // mbrPayment: PayTxn gtxns Receiver @@ -232,19 +232,19 @@ upload: // Push empty bytes after the frame pointer to reserve space for local variables byte 0x - // contracts/algo-did.algo.ts:98 + // contracts/did-algo-storage.algo.ts:98 // assert(this.txn.sender === globals.creatorAddress) txn Sender global CreatorAddress == assert - // contracts/algo-did.algo.ts:100 + // contracts/did-algo-storage.algo.ts:100 // metadata = this.metadata(pubKey).value frame_dig -1 // pubKey: Address frame_bury 0 // storage key//metadata - // contracts/algo-did.algo.ts:101 + // contracts/did-algo-storage.algo.ts:101 // assert(metadata.status === UPLOADING) frame_dig -1 // pubKey: Address int 16 // headOffset @@ -255,7 +255,7 @@ upload: == assert - // contracts/algo-did.algo.ts:102 + // contracts/did-algo-storage.algo.ts:102 // assert(metadata.start <= boxIndex && boxIndex <= metadata.end) frame_dig -1 // pubKey: Address int 0 @@ -279,7 +279,7 @@ upload: assert // *if0_condition - // contracts/algo-did.algo.ts:104 + // contracts/did-algo-storage.algo.ts:104 // offset === 0 frame_dig -3 // offset: uint64 int 0 @@ -287,7 +287,7 @@ upload: bz *if0_end // *if0_consequent - // contracts/algo-did.algo.ts:105 + // contracts/did-algo-storage.algo.ts:105 // this.dataBoxes(boxIndex).create(boxIndex === metadata.end ? metadata.endSize : MAX_BOX_SIZE) frame_dig -2 // boxIndex: uint64 itob @@ -314,7 +314,7 @@ upload: pop *if0_end: - // contracts/algo-did.algo.ts:108 + // contracts/did-algo-storage.algo.ts:108 // this.dataBoxes(boxIndex).replace(offset, data) frame_dig -2 // boxIndex: uint64 itob @@ -349,14 +349,14 @@ upload: finishUpload: proto 1 0 - // contracts/algo-did.algo.ts:118 + // contracts/did-algo-storage.algo.ts:118 // assert(this.txn.sender === globals.creatorAddress) txn Sender global CreatorAddress == assert - // contracts/algo-did.algo.ts:120 + // contracts/did-algo-storage.algo.ts:120 // this.metadata(pubKey).value.status = READY frame_dig -1 // pubKey: Address int 16 // headOffset @@ -392,19 +392,19 @@ startDelete: // Push empty bytes after the frame pointer to reserve space for local variables byte 0x - // contracts/algo-did.algo.ts:129 + // contracts/did-algo-storage.algo.ts:129 // assert(this.txn.sender === globals.creatorAddress) txn Sender global CreatorAddress == assert - // contracts/algo-did.algo.ts:131 + // contracts/did-algo-storage.algo.ts:131 // metadata = this.metadata(pubKey).value frame_dig -1 // pubKey: Address frame_bury 0 // storage key//metadata - // contracts/algo-did.algo.ts:132 + // contracts/did-algo-storage.algo.ts:132 // assert(metadata.status === READY) frame_dig -1 // pubKey: Address int 16 // headOffset @@ -415,7 +415,7 @@ startDelete: == assert - // contracts/algo-did.algo.ts:134 + // contracts/did-algo-storage.algo.ts:134 // metadata.status = DELETING frame_dig 0 // storage key//metadata int 16 // headOffset @@ -457,19 +457,19 @@ deleteData: byte 0x dup - // contracts/algo-did.algo.ts:144 + // contracts/did-algo-storage.algo.ts:144 // assert(this.txn.sender === globals.creatorAddress) txn Sender global CreatorAddress == assert - // contracts/algo-did.algo.ts:146 + // contracts/did-algo-storage.algo.ts:146 // metadata = this.metadata(pubKey).value frame_dig -1 // pubKey: Address frame_bury 0 // storage key//metadata - // contracts/algo-did.algo.ts:147 + // contracts/did-algo-storage.algo.ts:147 // assert(metadata.status === DELETING) frame_dig -1 // pubKey: Address int 16 // headOffset @@ -480,7 +480,7 @@ deleteData: == assert - // contracts/algo-did.algo.ts:148 + // contracts/did-algo-storage.algo.ts:148 // assert(metadata.start <= boxIndex && boxIndex <= metadata.end) frame_dig -1 // pubKey: Address int 0 @@ -504,7 +504,7 @@ deleteData: assert // *if1_condition - // contracts/algo-did.algo.ts:150 + // contracts/did-algo-storage.algo.ts:150 // boxIndex !== metadata.start frame_dig -2 // boxIndex: uint64 frame_dig -1 // pubKey: Address @@ -516,7 +516,7 @@ deleteData: bz *if1_end // *if1_consequent - // contracts/algo-did.algo.ts:150 + // contracts/did-algo-storage.algo.ts:150 // assert(metadata.lastDeleted === boxIndex - 1) frame_dig -1 // pubKey: Address int 25 // headOffset @@ -530,21 +530,21 @@ deleteData: assert *if1_end: - // contracts/algo-did.algo.ts:152 + // contracts/did-algo-storage.algo.ts:152 // preMBR = globals.currentApplicationAddress.minBalance global CurrentApplicationAddress acct_params_get AcctMinBalance pop frame_bury 1 // preMBR: uint64 - // contracts/algo-did.algo.ts:154 + // contracts/did-algo-storage.algo.ts:154 // this.dataBoxes(boxIndex).delete() frame_dig -2 // boxIndex: uint64 itob box_del // *if2_condition - // contracts/algo-did.algo.ts:156 + // contracts/did-algo-storage.algo.ts:156 // boxIndex === metadata.end frame_dig -2 // boxIndex: uint64 frame_dig -1 // pubKey: Address @@ -556,14 +556,14 @@ deleteData: bz *if2_else // *if2_consequent - // contracts/algo-did.algo.ts:156 + // contracts/did-algo-storage.algo.ts:156 // this.metadata(pubKey).delete() frame_dig -1 // pubKey: Address box_del b *if2_end *if2_else: - // contracts/algo-did.algo.ts:157 + // contracts/did-algo-storage.algo.ts:157 // metadata.lastDeleted = boxIndex int 25 // headOffset frame_dig -2 // boxIndex: uint64 @@ -573,7 +573,7 @@ deleteData: box_replace *if2_end: - // contracts/algo-did.algo.ts:159 + // contracts/did-algo-storage.algo.ts:159 // sendPayment({ // amount: preMBR - globals.currentApplicationAddress.minBalance, // receiver: this.txn.sender, @@ -582,7 +582,7 @@ deleteData: int pay itxn_field TypeEnum - // contracts/algo-did.algo.ts:160 + // contracts/did-algo-storage.algo.ts:160 // amount: preMBR - globals.currentApplicationAddress.minBalance frame_dig 1 // preMBR: uint64 global CurrentApplicationAddress @@ -591,7 +591,7 @@ deleteData: - itxn_field Amount - // contracts/algo-did.algo.ts:161 + // contracts/did-algo-storage.algo.ts:161 // receiver: this.txn.sender txn Sender itxn_field Receiver @@ -617,7 +617,7 @@ deleteData: updateApplication: proto 0 0 - // contracts/algo-did.algo.ts:169 + // contracts/did-algo-storage.algo.ts:169 // assert(this.txn.sender === globals.creatorAddress) txn Sender global CreatorAddress diff --git a/client/internal/contracts/DIDAlgoStorage.arc32.json b/client/internal/contracts/DIDAlgoStorage.arc32.json new file mode 100644 index 0000000..c72c61e --- /dev/null +++ b/client/internal/contracts/DIDAlgoStorage.arc32.json @@ -0,0 +1,214 @@ +{ + "hints": { + "startUpload(address,uint64,uint64,pay)void": { + "call_config": { + "no_op": "CALL" + } + }, + "upload(address,uint64,uint64,byte[])void": { + "call_config": { + "no_op": "CALL" + } + }, + "finishUpload(address)void": { + "call_config": { + "no_op": "CALL" + } + }, + "startDelete(address)void": { + "call_config": { + "no_op": "CALL" + } + }, + "deleteData(address,uint64)void": { + "call_config": { + "no_op": "CALL" + } + }, + "updateApplication()void": { + "call_config": { + "update_application": "CALL" + } + }, + "dummy()void": { + "call_config": { + "no_op": "CALL" + } + }, + "createApplication()void": { + "call_config": { + "no_op": "CREATE" + } + } + }, + "bare_call_config": { + "no_op": "NEVER", + "opt_in": "NEVER", + "close_out": "NEVER", + "update_application": "NEVER", + "delete_application": "NEVER" + }, + "schema": { + "local": { + "declared": {}, + "reserved": {} + }, + "global": { + "declared": { + "currentIndex": { + "type": "uint64", + "key": "currentIndex" + } + }, + "reserved": {} + } + }, + "state": { + "global": { + "num_byte_slices": 0, + "num_uints": 1 + }, + "local": { + "num_byte_slices": 0, + "num_uints": 0 + } + }, + "source": { + "approval": "#pragma version 10

// This TEAL was generated by TEALScript v0.96.0
// https://github.com/algorandfoundation/TEALScript

// This contract is compliant with and/or implements the following ARCs: [ ARC4 ]

// The following ten lines of TEAL handle initial program flow
// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed
// Here, action refers to the OnComplete in combination with whether the app is being created or called
// Every possible action for this contract is represented in the switch statement
// If the action is not implemented in the contract, its respective branch will be "*NOT_IMPLEMENTED" which just contains "err"
txn ApplicationID
!
int 6
*
txn OnCompletion
+
switch *call_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *call_UpdateApplication *NOT_IMPLEMENTED *create_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED

*NOT_IMPLEMENTED:
	// The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?
	err

// startUpload(address,uint64,uint64,pay)void
*abi_route_startUpload:
	// mbrPayment: pay
	txn GroupIndex
	int 1
	-
	dup
	gtxns TypeEnum
	int pay
	==

	// argument 0 (mbrPayment) for startUpload must be a pay transaction
	assert

	// endBoxSize: uint64
	txna ApplicationArgs 3
	btoi

	// numBoxes: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 3 (pubKey) for startUpload must be a address
	assert

	// execute startUpload(address,uint64,uint64,pay)void
	callsub startUpload
	int 1
	return

// startUpload(pubKey: Address, numBoxes: uint64, endBoxSize: uint64, mbrPayment: PayTxn): void
//
//
// Allocate boxes to begin data upload process
//
// @param pubKey The pubkey of the DID
// @param numBoxes The number of boxes that the data will take up
// @param endBoxSize The size of the last box
// @param mbrPayment Payment from the uploader to cover the box MBR
startUpload:
	proto 4 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x
	dupn 3

	// contracts/did-algo-storage.algo.ts:63
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/did-algo-storage.algo.ts:65
	// startBox = this.currentIndex.value
	byte 0x63757272656e74496e646578 // "currentIndex"
	app_global_get
	frame_bury 0 // startBox: uint64

	// contracts/did-algo-storage.algo.ts:66
	// endBox = startBox + numBoxes - 1
	frame_dig 0 // startBox: uint64
	frame_dig -2 // numBoxes: uint64
	+
	int 1
	-
	frame_bury 1 // endBox: uint64

	// contracts/did-algo-storage.algo.ts:68
	// metadata: Metadata = {
	//       start: startBox, end: endBox, status: UPLOADING, endSize: endBoxSize, lastDeleted: 0,
	//     }
	frame_dig 0 // startBox: uint64
	itob
	frame_dig 1 // endBox: uint64
	itob
	concat
	byte 0x00
	concat
	frame_dig -3 // endBoxSize: uint64
	itob
	concat
	byte 0x0000000000000000
	concat
	frame_bury 2 // metadata: Metadata

	// contracts/did-algo-storage.algo.ts:72
	// assert(!this.metadata(pubKey).exists)
	frame_dig -1 // pubKey: Address
	box_len
	swap
	pop
	!
	assert

	// contracts/did-algo-storage.algo.ts:74
	// this.metadata(pubKey).value = metadata
	frame_dig -1 // pubKey: Address
	frame_dig 2 // metadata: Metadata
	box_put

	// contracts/did-algo-storage.algo.ts:76
	// this.currentIndex.value = endBox + 1
	byte 0x63757272656e74496e646578 // "currentIndex"
	frame_dig 1 // endBox: uint64
	int 1
	+
	app_global_put

	// contracts/did-algo-storage.algo.ts:78
	// totalCost = numBoxes * COST_PER_BOX // cost of data boxes
	//     + (numBoxes - 1) * MAX_BOX_SIZE * COST_PER_BYTE // cost of data
	//     + numBoxes * 8 * COST_PER_BYTE // cost of data keys
	//     + endBoxSize * COST_PER_BYTE // cost of last data box
	//     + COST_PER_BOX + (8 + 8 + 1 + 8 + 32 + 8) * COST_PER_BYTE
	frame_dig -2 // numBoxes: uint64
	int 2500
	*
	frame_dig -2 // numBoxes: uint64
	int 1
	-
	int 32768
	*
	int 400
	*
	+
	frame_dig -2 // numBoxes: uint64
	int 8
	*
	int 400
	*
	+
	frame_dig -3 // endBoxSize: uint64
	int 400
	*
	+
	int 2500
	+
	int 26000
	+
	frame_bury 3 // totalCost: uint64

	// contracts/did-algo-storage.algo.ts:84
	// assert(mbrPayment.amount === totalCost)
	frame_dig -4 // mbrPayment: PayTxn
	gtxns Amount
	frame_dig 3 // totalCost: uint64
	==
	assert

	// contracts/did-algo-storage.algo.ts:85
	// assert(mbrPayment.receiver === this.app.address)
	frame_dig -4 // mbrPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==
	assert
	retsub

// upload(address,uint64,uint64,byte[])void
*abi_route_upload:
	// data: byte[]
	txna ApplicationArgs 4
	extract 2 0

	// offset: uint64
	txna ApplicationArgs 3
	btoi

	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 3 (pubKey) for upload must be a address
	assert

	// execute upload(address,uint64,uint64,byte[])void
	callsub upload
	int 1
	return

// upload(pubKey: Address, boxIndex: uint64, offset: uint64, data: bytes): void
//
//
// Upload data to a specific offset in a box
//
// @param pubKey The pubkey of the DID
// @param boxIndex The index of the box to upload the given chunk of data to
// @param offset The offset within the box to start writing the data
// @param data The data to write
upload:
	proto 4 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x

	// contracts/did-algo-storage.algo.ts:98
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/did-algo-storage.algo.ts:100
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: Address
	frame_bury 0 // storage key//metadata

	// contracts/did-algo-storage.algo.ts:101
	// assert(metadata.status === UPLOADING)
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	int 1
	box_extract
	btoi
	int 0
	==
	assert

	// contracts/did-algo-storage.algo.ts:102
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -1 // pubKey: Address
	int 0
	int 8
	box_extract
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz *skip_and0
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	<=
	&&

*skip_and0:
	assert

	// *if0_condition
	// contracts/did-algo-storage.algo.ts:104
	// offset === 0
	frame_dig -3 // offset: uint64
	int 0
	==
	bz *if0_end

	// *if0_consequent
	// contracts/did-algo-storage.algo.ts:105
	// this.dataBoxes(boxIndex).create(boxIndex === metadata.end ? metadata.endSize : MAX_BOX_SIZE)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	==
	bz *ternary0_false
	frame_dig -1 // pubKey: Address
	int 17 // headOffset
	int 8
	box_extract
	btoi
	b *ternary0_end

*ternary0_false:
	int 32768

*ternary0_end:
	box_create
	pop

*if0_end:
	// contracts/did-algo-storage.algo.ts:108
	// this.dataBoxes(boxIndex).replace(offset, data)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -3 // offset: uint64
	frame_dig -4 // data: bytes
	box_replace
	retsub

// finishUpload(address)void
*abi_route_finishUpload:
	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 0 (pubKey) for finishUpload must be a address
	assert

	// execute finishUpload(address)void
	callsub finishUpload
	int 1
	return

// finishUpload(pubKey: Address): void
//
//
// Mark uploading as false
//
// @param pubKey The address of the DID
finishUpload:
	proto 1 0

	// contracts/did-algo-storage.algo.ts:118
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/did-algo-storage.algo.ts:120
	// this.metadata(pubKey).value.status = READY
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	byte 0x01
	box_replace
	retsub

// startDelete(address)void
*abi_route_startDelete:
	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 0 (pubKey) for startDelete must be a address
	assert

	// execute startDelete(address)void
	callsub startDelete
	int 1
	return

// startDelete(pubKey: Address): void
//
// Starts the deletion process for the data associated with a DID
//
// @param pubKey The address of the DID
startDelete:
	proto 1 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x

	// contracts/did-algo-storage.algo.ts:129
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/did-algo-storage.algo.ts:131
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: Address
	frame_bury 0 // storage key//metadata

	// contracts/did-algo-storage.algo.ts:132
	// assert(metadata.status === READY)
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	int 1
	box_extract
	btoi
	int 1
	==
	assert

	// contracts/did-algo-storage.algo.ts:134
	// metadata.status = DELETING
	frame_dig 0 // storage key//metadata
	int 16 // headOffset
	byte 0x02
	box_replace
	retsub

// deleteData(address,uint64)void
*abi_route_deleteData:
	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 1 (pubKey) for deleteData must be a address
	assert

	// execute deleteData(address,uint64)void
	callsub deleteData
	int 1
	return

// deleteData(pubKey: Address, boxIndex: uint64): void
//
// Deletes a box of data
//
// @param pubKey The address of the DID
// @param boxIndex The index of the box to delete
deleteData:
	proto 2 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x
	dup

	// contracts/did-algo-storage.algo.ts:144
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/did-algo-storage.algo.ts:146
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: Address
	frame_bury 0 // storage key//metadata

	// contracts/did-algo-storage.algo.ts:147
	// assert(metadata.status === DELETING)
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	int 1
	box_extract
	btoi
	int 2
	==
	assert

	// contracts/did-algo-storage.algo.ts:148
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -1 // pubKey: Address
	int 0
	int 8
	box_extract
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz *skip_and1
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	<=
	&&

*skip_and1:
	assert

	// *if1_condition
	// contracts/did-algo-storage.algo.ts:150
	// boxIndex !== metadata.start
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 0
	int 8
	box_extract
	btoi
	!=
	bz *if1_end

	// *if1_consequent
	// contracts/did-algo-storage.algo.ts:150
	// assert(metadata.lastDeleted === boxIndex - 1)
	frame_dig -1 // pubKey: Address
	int 25 // headOffset
	int 8
	box_extract
	btoi
	frame_dig -2 // boxIndex: uint64
	int 1
	-
	==
	assert

*if1_end:
	// contracts/did-algo-storage.algo.ts:152
	// preMBR = globals.currentApplicationAddress.minBalance
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	pop
	frame_bury 1 // preMBR: uint64

	// contracts/did-algo-storage.algo.ts:154
	// this.dataBoxes(boxIndex).delete()
	frame_dig -2 // boxIndex: uint64
	itob
	box_del

	// *if2_condition
	// contracts/did-algo-storage.algo.ts:156
	// boxIndex === metadata.end
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	==
	bz *if2_else

	// *if2_consequent
	// contracts/did-algo-storage.algo.ts:156
	// this.metadata(pubKey).delete()
	frame_dig -1 // pubKey: Address
	box_del
	b *if2_end

*if2_else:
	// contracts/did-algo-storage.algo.ts:157
	// metadata.lastDeleted = boxIndex
	int 25 // headOffset
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig 0 // storage key//metadata
	cover 2
	box_replace

*if2_end:
	// contracts/did-algo-storage.algo.ts:159
	// sendPayment({
	//       amount: preMBR - globals.currentApplicationAddress.minBalance,
	//       receiver: this.txn.sender,
	//     })
	itxn_begin
	int pay
	itxn_field TypeEnum

	// contracts/did-algo-storage.algo.ts:160
	// amount: preMBR - globals.currentApplicationAddress.minBalance
	frame_dig 1 // preMBR: uint64
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	pop
	-
	itxn_field Amount

	// contracts/did-algo-storage.algo.ts:161
	// receiver: this.txn.sender
	txn Sender
	itxn_field Receiver

	// Fee field not set, defaulting to 0
	int 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// updateApplication()void
*abi_route_updateApplication:
	// execute updateApplication()void
	callsub updateApplication
	int 1
	return

// updateApplication(): void
//
// Allow the contract to be updated by the creator
updateApplication:
	proto 0 0

	// contracts/did-algo-storage.algo.ts:169
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert
	retsub

// dummy()void
*abi_route_dummy:
	// execute dummy()void
	callsub dummy
	int 1
	return

// dummy(): void
//
// Dummy function to add extra box references for deleteData.
// Boxes are 32k, but a single app call can only inlcude enough references to read/write 8k
// at a time. Thus when a box is deleted, we need to add additional dummy calls with box
// references to increase the total read/write budget to 32k.
dummy:
	proto 0 0
	retsub

*abi_route_createApplication:
	int 1
	return

*create_NoOp:
	method "createApplication()void"
	txna ApplicationArgs 0
	match *abi_route_createApplication

	// this contract does not implement the given ABI method for create NoOp
	err

*call_NoOp:
	method "startUpload(address,uint64,uint64,pay)void"
	method "upload(address,uint64,uint64,byte[])void"
	method "finishUpload(address)void"
	method "startDelete(address)void"
	method "deleteData(address,uint64)void"
	method "dummy()void"
	txna ApplicationArgs 0
	match *abi_route_startUpload *abi_route_upload *abi_route_finishUpload *abi_route_startDelete *abi_route_deleteData *abi_route_dummy

	// this contract does not implement the given ABI method for call NoOp
	err

*call_UpdateApplication:
	method "updateApplication()void"
	txna ApplicationArgs 0
	match *abi_route_updateApplication

	// this contract does not implement the given ABI method for call UpdateApplication
	err", + "clear": "I3ByYWdtYSB2ZXJzaW9uIDEw" + }, + "contract": { + "name": "DIDAlgoStorage", + "desc": "", + "methods": [ + { + "name": "startUpload", + "desc": "Allocate boxes to begin data upload process", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The pubkey of the DID" + }, + { + "name": "numBoxes", + "type": "uint64", + "desc": "The number of boxes that the data will take up" + }, + { + "name": "endBoxSize", + "type": "uint64", + "desc": "The size of the last box" + }, + { + "name": "mbrPayment", + "type": "pay", + "desc": "Payment from the uploader to cover the box MBR" + } + ], + "returns": { + "type": "void" + } + }, + { + "name": "upload", + "desc": "Upload data to a specific offset in a box", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The pubkey of the DID" + }, + { + "name": "boxIndex", + "type": "uint64", + "desc": "The index of the box to upload the given chunk of data to" + }, + { + "name": "offset", + "type": "uint64", + "desc": "The offset within the box to start writing the data" + }, + { + "name": "data", + "type": "byte[]", + "desc": "The data to write" + } + ], + "returns": { + "type": "void" + } + }, + { + "name": "finishUpload", + "desc": "Mark uploading as false", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + } + ], + "returns": { + "type": "void" + } + }, + { + "name": "startDelete", + "desc": "Starts the deletion process for the data associated with a DID", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + } + ], + "returns": { + "type": "void" + } + }, + { + "name": "deleteData", + "desc": "Deletes a box of data", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + }, + { + "name": "boxIndex", + "type": "uint64", + "desc": "The index of the box to delete" + } + ], + "returns": { + "type": "void" + } + }, + { + "name": "updateApplication", + "desc": "Allow the contract to be updated by the creator", + "args": [], + "returns": { + "type": "void" + } + }, + { + "name": "dummy", + "desc": "Dummy function to add extra box references for deleteData.Boxes are 32k, but a single app call can only inlcude enough references to read/write 8kat a time. Thus when a box is deleted, we need to add additional dummy calls with boxreferences to increase the total read/write budget to 32k.", + "args": [], + "returns": { + "type": "void" + } + }, + { + "name": "createApplication", + "args": [], + "returns": { + "type": "void" + } + } + ] + } +} \ No newline at end of file diff --git a/reference_contract/contracts/artifacts/AlgoDID.arc4.json b/client/internal/contracts/DIDAlgoStorage.arc4.json similarity index 99% rename from reference_contract/contracts/artifacts/AlgoDID.arc4.json rename to client/internal/contracts/DIDAlgoStorage.arc4.json index 59184cc..9fc6009 100644 --- a/reference_contract/contracts/artifacts/AlgoDID.arc4.json +++ b/client/internal/contracts/DIDAlgoStorage.arc4.json @@ -1,5 +1,5 @@ { - "name": "AlgoDID", + "name": "DIDAlgoStorage", "desc": "", "methods": [ { diff --git a/client/internal/contracts/AlgoDID.arc56_draft.json b/client/internal/contracts/DIDAlgoStorage.arc56_draft.json similarity index 75% rename from client/internal/contracts/AlgoDID.arc56_draft.json rename to client/internal/contracts/DIDAlgoStorage.arc56_draft.json index 497ad1a..3f017ac 100644 --- a/client/internal/contracts/AlgoDID.arc56_draft.json +++ b/client/internal/contracts/DIDAlgoStorage.arc56_draft.json @@ -1,5 +1,5 @@ { - "name": "AlgoDID", + "name": "DIDAlgoStorage", "desc": "", "methods": [ { @@ -3170,7 +3170,7 @@ } ], "source": { - "approval": "#pragma version 10

// This TEAL was generated by TEALScript v0.96.0
// https://github.com/algorandfoundation/TEALScript

// This contract is compliant with and/or implements the following ARCs: [ ARC4 ]

// The following ten lines of TEAL handle initial program flow
// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed
// Here, action refers to the OnComplete in combination with whether the app is being created or called
// Every possible action for this contract is represented in the switch statement
// If the action is not implemented in the contract, its respective branch will be "*NOT_IMPLEMENTED" which just contains "err"
txn ApplicationID
!
int 6
*
txn OnCompletion
+
switch *call_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *call_UpdateApplication *NOT_IMPLEMENTED *create_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED

*NOT_IMPLEMENTED:
	// The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?
	err

// startUpload(address,uint64,uint64,pay)void
*abi_route_startUpload:
	// mbrPayment: pay
	txn GroupIndex
	int 1
	-
	dup
	gtxns TypeEnum
	int pay
	==

	// argument 0 (mbrPayment) for startUpload must be a pay transaction
	assert

	// endBoxSize: uint64
	txna ApplicationArgs 3
	btoi

	// numBoxes: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 3 (pubKey) for startUpload must be a address
	assert

	// execute startUpload(address,uint64,uint64,pay)void
	callsub startUpload
	int 1
	return

// startUpload(pubKey: Address, numBoxes: uint64, endBoxSize: uint64, mbrPayment: PayTxn): void
//
//
// Allocate boxes to begin data upload process
//
// @param pubKey The pubkey of the DID
// @param numBoxes The number of boxes that the data will take up
// @param endBoxSize The size of the last box
// @param mbrPayment Payment from the uploader to cover the box MBR
startUpload:
	proto 4 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x
	dupn 3

	// contracts/algo-did.algo.ts:63
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:65
	// startBox = this.currentIndex.value
	byte 0x63757272656e74496e646578 // "currentIndex"
	app_global_get
	frame_bury 0 // startBox: uint64

	// contracts/algo-did.algo.ts:66
	// endBox = startBox + numBoxes - 1
	frame_dig 0 // startBox: uint64
	frame_dig -2 // numBoxes: uint64
	+
	int 1
	-
	frame_bury 1 // endBox: uint64

	// contracts/algo-did.algo.ts:68
	// metadata: Metadata = {
	//       start: startBox, end: endBox, status: UPLOADING, endSize: endBoxSize, lastDeleted: 0,
	//     }
	frame_dig 0 // startBox: uint64
	itob
	frame_dig 1 // endBox: uint64
	itob
	concat
	byte 0x00
	concat
	frame_dig -3 // endBoxSize: uint64
	itob
	concat
	byte 0x0000000000000000
	concat
	frame_bury 2 // metadata: Metadata

	// contracts/algo-did.algo.ts:72
	// assert(!this.metadata(pubKey).exists)
	frame_dig -1 // pubKey: Address
	box_len
	swap
	pop
	!
	assert

	// contracts/algo-did.algo.ts:74
	// this.metadata(pubKey).value = metadata
	frame_dig -1 // pubKey: Address
	frame_dig 2 // metadata: Metadata
	box_put

	// contracts/algo-did.algo.ts:76
	// this.currentIndex.value = endBox + 1
	byte 0x63757272656e74496e646578 // "currentIndex"
	frame_dig 1 // endBox: uint64
	int 1
	+
	app_global_put

	// contracts/algo-did.algo.ts:78
	// totalCost = numBoxes * COST_PER_BOX // cost of data boxes
	//     + (numBoxes - 1) * MAX_BOX_SIZE * COST_PER_BYTE // cost of data
	//     + numBoxes * 8 * COST_PER_BYTE // cost of data keys
	//     + endBoxSize * COST_PER_BYTE // cost of last data box
	//     + COST_PER_BOX + (8 + 8 + 1 + 8 + 32 + 8) * COST_PER_BYTE
	frame_dig -2 // numBoxes: uint64
	int 2500
	*
	frame_dig -2 // numBoxes: uint64
	int 1
	-
	int 32768
	*
	int 400
	*
	+
	frame_dig -2 // numBoxes: uint64
	int 8
	*
	int 400
	*
	+
	frame_dig -3 // endBoxSize: uint64
	int 400
	*
	+
	int 2500
	+
	int 26000
	+
	frame_bury 3 // totalCost: uint64

	// contracts/algo-did.algo.ts:84
	// assert(mbrPayment.amount === totalCost)
	frame_dig -4 // mbrPayment: PayTxn
	gtxns Amount
	frame_dig 3 // totalCost: uint64
	==
	assert

	// contracts/algo-did.algo.ts:85
	// assert(mbrPayment.receiver === this.app.address)
	frame_dig -4 // mbrPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==
	assert
	retsub

// upload(address,uint64,uint64,byte[])void
*abi_route_upload:
	// data: byte[]
	txna ApplicationArgs 4
	extract 2 0

	// offset: uint64
	txna ApplicationArgs 3
	btoi

	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 3 (pubKey) for upload must be a address
	assert

	// execute upload(address,uint64,uint64,byte[])void
	callsub upload
	int 1
	return

// upload(pubKey: Address, boxIndex: uint64, offset: uint64, data: bytes): void
//
//
// Upload data to a specific offset in a box
//
// @param pubKey The pubkey of the DID
// @param boxIndex The index of the box to upload the given chunk of data to
// @param offset The offset within the box to start writing the data
// @param data The data to write
upload:
	proto 4 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x

	// contracts/algo-did.algo.ts:98
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:100
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: Address
	frame_bury 0 // storage key//metadata

	// contracts/algo-did.algo.ts:101
	// assert(metadata.status === UPLOADING)
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	int 1
	box_extract
	btoi
	int 0
	==
	assert

	// contracts/algo-did.algo.ts:102
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -1 // pubKey: Address
	int 0
	int 8
	box_extract
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz *skip_and0
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	<=
	&&

*skip_and0:
	assert

	// *if0_condition
	// contracts/algo-did.algo.ts:104
	// offset === 0
	frame_dig -3 // offset: uint64
	int 0
	==
	bz *if0_end

	// *if0_consequent
	// contracts/algo-did.algo.ts:105
	// this.dataBoxes(boxIndex).create(boxIndex === metadata.end ? metadata.endSize : MAX_BOX_SIZE)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	==
	bz *ternary0_false
	frame_dig -1 // pubKey: Address
	int 17 // headOffset
	int 8
	box_extract
	btoi
	b *ternary0_end

*ternary0_false:
	int 32768

*ternary0_end:
	box_create
	pop

*if0_end:
	// contracts/algo-did.algo.ts:108
	// this.dataBoxes(boxIndex).replace(offset, data)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -3 // offset: uint64
	frame_dig -4 // data: bytes
	box_replace
	retsub

// finishUpload(address)void
*abi_route_finishUpload:
	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 0 (pubKey) for finishUpload must be a address
	assert

	// execute finishUpload(address)void
	callsub finishUpload
	int 1
	return

// finishUpload(pubKey: Address): void
//
//
// Mark uploading as false
//
// @param pubKey The address of the DID
finishUpload:
	proto 1 0

	// contracts/algo-did.algo.ts:118
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:120
	// this.metadata(pubKey).value.status = READY
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	byte 0x01
	box_replace
	retsub

// startDelete(address)void
*abi_route_startDelete:
	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 0 (pubKey) for startDelete must be a address
	assert

	// execute startDelete(address)void
	callsub startDelete
	int 1
	return

// startDelete(pubKey: Address): void
//
// Starts the deletion process for the data associated with a DID
//
// @param pubKey The address of the DID
startDelete:
	proto 1 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x

	// contracts/algo-did.algo.ts:129
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:131
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: Address
	frame_bury 0 // storage key//metadata

	// contracts/algo-did.algo.ts:132
	// assert(metadata.status === READY)
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	int 1
	box_extract
	btoi
	int 1
	==
	assert

	// contracts/algo-did.algo.ts:134
	// metadata.status = DELETING
	frame_dig 0 // storage key//metadata
	int 16 // headOffset
	byte 0x02
	box_replace
	retsub

// deleteData(address,uint64)void
*abi_route_deleteData:
	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 1 (pubKey) for deleteData must be a address
	assert

	// execute deleteData(address,uint64)void
	callsub deleteData
	int 1
	return

// deleteData(pubKey: Address, boxIndex: uint64): void
//
// Deletes a box of data
//
// @param pubKey The address of the DID
// @param boxIndex The index of the box to delete
deleteData:
	proto 2 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x
	dup

	// contracts/algo-did.algo.ts:144
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:146
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: Address
	frame_bury 0 // storage key//metadata

	// contracts/algo-did.algo.ts:147
	// assert(metadata.status === DELETING)
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	int 1
	box_extract
	btoi
	int 2
	==
	assert

	// contracts/algo-did.algo.ts:148
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -1 // pubKey: Address
	int 0
	int 8
	box_extract
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz *skip_and1
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	<=
	&&

*skip_and1:
	assert

	// *if1_condition
	// contracts/algo-did.algo.ts:150
	// boxIndex !== metadata.start
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 0
	int 8
	box_extract
	btoi
	!=
	bz *if1_end

	// *if1_consequent
	// contracts/algo-did.algo.ts:150
	// assert(metadata.lastDeleted === boxIndex - 1)
	frame_dig -1 // pubKey: Address
	int 25 // headOffset
	int 8
	box_extract
	btoi
	frame_dig -2 // boxIndex: uint64
	int 1
	-
	==
	assert

*if1_end:
	// contracts/algo-did.algo.ts:152
	// preMBR = globals.currentApplicationAddress.minBalance
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	pop
	frame_bury 1 // preMBR: uint64

	// contracts/algo-did.algo.ts:154
	// this.dataBoxes(boxIndex).delete()
	frame_dig -2 // boxIndex: uint64
	itob
	box_del

	// *if2_condition
	// contracts/algo-did.algo.ts:156
	// boxIndex === metadata.end
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	==
	bz *if2_else

	// *if2_consequent
	// contracts/algo-did.algo.ts:156
	// this.metadata(pubKey).delete()
	frame_dig -1 // pubKey: Address
	box_del
	b *if2_end

*if2_else:
	// contracts/algo-did.algo.ts:157
	// metadata.lastDeleted = boxIndex
	int 25 // headOffset
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig 0 // storage key//metadata
	cover 2
	box_replace

*if2_end:
	// contracts/algo-did.algo.ts:159
	// sendPayment({
	//       amount: preMBR - globals.currentApplicationAddress.minBalance,
	//       receiver: this.txn.sender,
	//     })
	itxn_begin
	int pay
	itxn_field TypeEnum

	// contracts/algo-did.algo.ts:160
	// amount: preMBR - globals.currentApplicationAddress.minBalance
	frame_dig 1 // preMBR: uint64
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	pop
	-
	itxn_field Amount

	// contracts/algo-did.algo.ts:161
	// receiver: this.txn.sender
	txn Sender
	itxn_field Receiver

	// Fee field not set, defaulting to 0
	int 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// updateApplication()void
*abi_route_updateApplication:
	// execute updateApplication()void
	callsub updateApplication
	int 1
	return

// updateApplication(): void
//
// Allow the contract to be updated by the creator
updateApplication:
	proto 0 0

	// contracts/algo-did.algo.ts:169
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert
	retsub

// dummy()void
*abi_route_dummy:
	// execute dummy()void
	callsub dummy
	int 1
	return

// dummy(): void
//
// Dummy function to add extra box references for deleteData.
// Boxes are 32k, but a single app call can only inlcude enough references to read/write 8k
// at a time. Thus when a box is deleted, we need to add additional dummy calls with box
// references to increase the total read/write budget to 32k.
dummy:
	proto 0 0
	retsub

*abi_route_createApplication:
	int 1
	return

*create_NoOp:
	method "createApplication()void"
	txna ApplicationArgs 0
	match *abi_route_createApplication

	// this contract does not implement the given ABI method for create NoOp
	err

*call_NoOp:
	method "startUpload(address,uint64,uint64,pay)void"
	method "upload(address,uint64,uint64,byte[])void"
	method "finishUpload(address)void"
	method "startDelete(address)void"
	method "deleteData(address,uint64)void"
	method "dummy()void"
	txna ApplicationArgs 0
	match *abi_route_startUpload *abi_route_upload *abi_route_finishUpload *abi_route_startDelete *abi_route_deleteData *abi_route_dummy

	// this contract does not implement the given ABI method for call NoOp
	err

*call_UpdateApplication:
	method "updateApplication()void"
	txna ApplicationArgs 0
	match *abi_route_updateApplication

	// this contract does not implement the given ABI method for call UpdateApplication
	err", + "approval": "#pragma version 10

// This TEAL was generated by TEALScript v0.96.0
// https://github.com/algorandfoundation/TEALScript

// This contract is compliant with and/or implements the following ARCs: [ ARC4 ]

// The following ten lines of TEAL handle initial program flow
// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed
// Here, action refers to the OnComplete in combination with whether the app is being created or called
// Every possible action for this contract is represented in the switch statement
// If the action is not implemented in the contract, its respective branch will be "*NOT_IMPLEMENTED" which just contains "err"
txn ApplicationID
!
int 6
*
txn OnCompletion
+
switch *call_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *call_UpdateApplication *NOT_IMPLEMENTED *create_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED

*NOT_IMPLEMENTED:
	// The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?
	err

// startUpload(address,uint64,uint64,pay)void
*abi_route_startUpload:
	// mbrPayment: pay
	txn GroupIndex
	int 1
	-
	dup
	gtxns TypeEnum
	int pay
	==

	// argument 0 (mbrPayment) for startUpload must be a pay transaction
	assert

	// endBoxSize: uint64
	txna ApplicationArgs 3
	btoi

	// numBoxes: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 3 (pubKey) for startUpload must be a address
	assert

	// execute startUpload(address,uint64,uint64,pay)void
	callsub startUpload
	int 1
	return

// startUpload(pubKey: Address, numBoxes: uint64, endBoxSize: uint64, mbrPayment: PayTxn): void
//
//
// Allocate boxes to begin data upload process
//
// @param pubKey The pubkey of the DID
// @param numBoxes The number of boxes that the data will take up
// @param endBoxSize The size of the last box
// @param mbrPayment Payment from the uploader to cover the box MBR
startUpload:
	proto 4 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x
	dupn 3

	// contracts/did-algo-storage.algo.ts:63
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/did-algo-storage.algo.ts:65
	// startBox = this.currentIndex.value
	byte 0x63757272656e74496e646578 // "currentIndex"
	app_global_get
	frame_bury 0 // startBox: uint64

	// contracts/did-algo-storage.algo.ts:66
	// endBox = startBox + numBoxes - 1
	frame_dig 0 // startBox: uint64
	frame_dig -2 // numBoxes: uint64
	+
	int 1
	-
	frame_bury 1 // endBox: uint64

	// contracts/did-algo-storage.algo.ts:68
	// metadata: Metadata = {
	//       start: startBox, end: endBox, status: UPLOADING, endSize: endBoxSize, lastDeleted: 0,
	//     }
	frame_dig 0 // startBox: uint64
	itob
	frame_dig 1 // endBox: uint64
	itob
	concat
	byte 0x00
	concat
	frame_dig -3 // endBoxSize: uint64
	itob
	concat
	byte 0x0000000000000000
	concat
	frame_bury 2 // metadata: Metadata

	// contracts/did-algo-storage.algo.ts:72
	// assert(!this.metadata(pubKey).exists)
	frame_dig -1 // pubKey: Address
	box_len
	swap
	pop
	!
	assert

	// contracts/did-algo-storage.algo.ts:74
	// this.metadata(pubKey).value = metadata
	frame_dig -1 // pubKey: Address
	frame_dig 2 // metadata: Metadata
	box_put

	// contracts/did-algo-storage.algo.ts:76
	// this.currentIndex.value = endBox + 1
	byte 0x63757272656e74496e646578 // "currentIndex"
	frame_dig 1 // endBox: uint64
	int 1
	+
	app_global_put

	// contracts/did-algo-storage.algo.ts:78
	// totalCost = numBoxes * COST_PER_BOX // cost of data boxes
	//     + (numBoxes - 1) * MAX_BOX_SIZE * COST_PER_BYTE // cost of data
	//     + numBoxes * 8 * COST_PER_BYTE // cost of data keys
	//     + endBoxSize * COST_PER_BYTE // cost of last data box
	//     + COST_PER_BOX + (8 + 8 + 1 + 8 + 32 + 8) * COST_PER_BYTE
	frame_dig -2 // numBoxes: uint64
	int 2500
	*
	frame_dig -2 // numBoxes: uint64
	int 1
	-
	int 32768
	*
	int 400
	*
	+
	frame_dig -2 // numBoxes: uint64
	int 8
	*
	int 400
	*
	+
	frame_dig -3 // endBoxSize: uint64
	int 400
	*
	+
	int 2500
	+
	int 26000
	+
	frame_bury 3 // totalCost: uint64

	// contracts/did-algo-storage.algo.ts:84
	// assert(mbrPayment.amount === totalCost)
	frame_dig -4 // mbrPayment: PayTxn
	gtxns Amount
	frame_dig 3 // totalCost: uint64
	==
	assert

	// contracts/did-algo-storage.algo.ts:85
	// assert(mbrPayment.receiver === this.app.address)
	frame_dig -4 // mbrPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==
	assert
	retsub

// upload(address,uint64,uint64,byte[])void
*abi_route_upload:
	// data: byte[]
	txna ApplicationArgs 4
	extract 2 0

	// offset: uint64
	txna ApplicationArgs 3
	btoi

	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 3 (pubKey) for upload must be a address
	assert

	// execute upload(address,uint64,uint64,byte[])void
	callsub upload
	int 1
	return

// upload(pubKey: Address, boxIndex: uint64, offset: uint64, data: bytes): void
//
//
// Upload data to a specific offset in a box
//
// @param pubKey The pubkey of the DID
// @param boxIndex The index of the box to upload the given chunk of data to
// @param offset The offset within the box to start writing the data
// @param data The data to write
upload:
	proto 4 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x

	// contracts/did-algo-storage.algo.ts:98
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/did-algo-storage.algo.ts:100
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: Address
	frame_bury 0 // storage key//metadata

	// contracts/did-algo-storage.algo.ts:101
	// assert(metadata.status === UPLOADING)
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	int 1
	box_extract
	btoi
	int 0
	==
	assert

	// contracts/did-algo-storage.algo.ts:102
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -1 // pubKey: Address
	int 0
	int 8
	box_extract
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz *skip_and0
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	<=
	&&

*skip_and0:
	assert

	// *if0_condition
	// contracts/did-algo-storage.algo.ts:104
	// offset === 0
	frame_dig -3 // offset: uint64
	int 0
	==
	bz *if0_end

	// *if0_consequent
	// contracts/did-algo-storage.algo.ts:105
	// this.dataBoxes(boxIndex).create(boxIndex === metadata.end ? metadata.endSize : MAX_BOX_SIZE)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	==
	bz *ternary0_false
	frame_dig -1 // pubKey: Address
	int 17 // headOffset
	int 8
	box_extract
	btoi
	b *ternary0_end

*ternary0_false:
	int 32768

*ternary0_end:
	box_create
	pop

*if0_end:
	// contracts/did-algo-storage.algo.ts:108
	// this.dataBoxes(boxIndex).replace(offset, data)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -3 // offset: uint64
	frame_dig -4 // data: bytes
	box_replace
	retsub

// finishUpload(address)void
*abi_route_finishUpload:
	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 0 (pubKey) for finishUpload must be a address
	assert

	// execute finishUpload(address)void
	callsub finishUpload
	int 1
	return

// finishUpload(pubKey: Address): void
//
//
// Mark uploading as false
//
// @param pubKey The address of the DID
finishUpload:
	proto 1 0

	// contracts/did-algo-storage.algo.ts:118
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/did-algo-storage.algo.ts:120
	// this.metadata(pubKey).value.status = READY
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	byte 0x01
	box_replace
	retsub

// startDelete(address)void
*abi_route_startDelete:
	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 0 (pubKey) for startDelete must be a address
	assert

	// execute startDelete(address)void
	callsub startDelete
	int 1
	return

// startDelete(pubKey: Address): void
//
// Starts the deletion process for the data associated with a DID
//
// @param pubKey The address of the DID
startDelete:
	proto 1 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x

	// contracts/did-algo-storage.algo.ts:129
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/did-algo-storage.algo.ts:131
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: Address
	frame_bury 0 // storage key//metadata

	// contracts/did-algo-storage.algo.ts:132
	// assert(metadata.status === READY)
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	int 1
	box_extract
	btoi
	int 1
	==
	assert

	// contracts/did-algo-storage.algo.ts:134
	// metadata.status = DELETING
	frame_dig 0 // storage key//metadata
	int 16 // headOffset
	byte 0x02
	box_replace
	retsub

// deleteData(address,uint64)void
*abi_route_deleteData:
	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 1 (pubKey) for deleteData must be a address
	assert

	// execute deleteData(address,uint64)void
	callsub deleteData
	int 1
	return

// deleteData(pubKey: Address, boxIndex: uint64): void
//
// Deletes a box of data
//
// @param pubKey The address of the DID
// @param boxIndex The index of the box to delete
deleteData:
	proto 2 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x
	dup

	// contracts/did-algo-storage.algo.ts:144
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/did-algo-storage.algo.ts:146
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: Address
	frame_bury 0 // storage key//metadata

	// contracts/did-algo-storage.algo.ts:147
	// assert(metadata.status === DELETING)
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	int 1
	box_extract
	btoi
	int 2
	==
	assert

	// contracts/did-algo-storage.algo.ts:148
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -1 // pubKey: Address
	int 0
	int 8
	box_extract
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz *skip_and1
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	<=
	&&

*skip_and1:
	assert

	// *if1_condition
	// contracts/did-algo-storage.algo.ts:150
	// boxIndex !== metadata.start
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 0
	int 8
	box_extract
	btoi
	!=
	bz *if1_end

	// *if1_consequent
	// contracts/did-algo-storage.algo.ts:150
	// assert(metadata.lastDeleted === boxIndex - 1)
	frame_dig -1 // pubKey: Address
	int 25 // headOffset
	int 8
	box_extract
	btoi
	frame_dig -2 // boxIndex: uint64
	int 1
	-
	==
	assert

*if1_end:
	// contracts/did-algo-storage.algo.ts:152
	// preMBR = globals.currentApplicationAddress.minBalance
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	pop
	frame_bury 1 // preMBR: uint64

	// contracts/did-algo-storage.algo.ts:154
	// this.dataBoxes(boxIndex).delete()
	frame_dig -2 // boxIndex: uint64
	itob
	box_del

	// *if2_condition
	// contracts/did-algo-storage.algo.ts:156
	// boxIndex === metadata.end
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	==
	bz *if2_else

	// *if2_consequent
	// contracts/did-algo-storage.algo.ts:156
	// this.metadata(pubKey).delete()
	frame_dig -1 // pubKey: Address
	box_del
	b *if2_end

*if2_else:
	// contracts/did-algo-storage.algo.ts:157
	// metadata.lastDeleted = boxIndex
	int 25 // headOffset
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig 0 // storage key//metadata
	cover 2
	box_replace

*if2_end:
	// contracts/did-algo-storage.algo.ts:159
	// sendPayment({
	//       amount: preMBR - globals.currentApplicationAddress.minBalance,
	//       receiver: this.txn.sender,
	//     })
	itxn_begin
	int pay
	itxn_field TypeEnum

	// contracts/did-algo-storage.algo.ts:160
	// amount: preMBR - globals.currentApplicationAddress.minBalance
	frame_dig 1 // preMBR: uint64
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	pop
	-
	itxn_field Amount

	// contracts/did-algo-storage.algo.ts:161
	// receiver: this.txn.sender
	txn Sender
	itxn_field Receiver

	// Fee field not set, defaulting to 0
	int 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// updateApplication()void
*abi_route_updateApplication:
	// execute updateApplication()void
	callsub updateApplication
	int 1
	return

// updateApplication(): void
//
// Allow the contract to be updated by the creator
updateApplication:
	proto 0 0

	// contracts/did-algo-storage.algo.ts:169
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert
	retsub

// dummy()void
*abi_route_dummy:
	// execute dummy()void
	callsub dummy
	int 1
	return

// dummy(): void
//
// Dummy function to add extra box references for deleteData.
// Boxes are 32k, but a single app call can only inlcude enough references to read/write 8k
// at a time. Thus when a box is deleted, we need to add additional dummy calls with box
// references to increase the total read/write budget to 32k.
dummy:
	proto 0 0
	retsub

*abi_route_createApplication:
	int 1
	return

*create_NoOp:
	method "createApplication()void"
	txna ApplicationArgs 0
	match *abi_route_createApplication

	// this contract does not implement the given ABI method for create NoOp
	err

*call_NoOp:
	method "startUpload(address,uint64,uint64,pay)void"
	method "upload(address,uint64,uint64,byte[])void"
	method "finishUpload(address)void"
	method "startDelete(address)void"
	method "deleteData(address,uint64)void"
	method "dummy()void"
	txna ApplicationArgs 0
	match *abi_route_startUpload *abi_route_upload *abi_route_finishUpload *abi_route_startDelete *abi_route_deleteData *abi_route_dummy

	// this contract does not implement the given ABI method for call NoOp
	err

*call_UpdateApplication:
	method "updateApplication()void"
	txna ApplicationArgs 0
	match *abi_route_updateApplication

	// this contract does not implement the given ABI method for call UpdateApplication
	err", "clear": "I3ByYWdtYSB2ZXJzaW9uIDEw" }, "byteCode": { diff --git a/client/internal/contracts/AlgoDID.clear.teal b/client/internal/contracts/DIDAlgoStorage.clear.teal similarity index 100% rename from client/internal/contracts/AlgoDID.clear.teal rename to client/internal/contracts/DIDAlgoStorage.clear.teal diff --git a/client/internal/contracts/AlgoDID.src_map.json b/client/internal/contracts/DIDAlgoStorage.src_map.json similarity index 100% rename from client/internal/contracts/AlgoDID.src_map.json rename to client/internal/contracts/DIDAlgoStorage.src_map.json diff --git a/reference_contract/README.md b/reference_contract/README.md index 89f9e5b..ee09a85 100644 --- a/reference_contract/README.md +++ b/reference_contract/README.md @@ -2,11 +2,11 @@ This is the reference implementation of the contract that will be used to store the DIDDocuments for `did:algo`. This is the contract that is used by the CLI tool by default when deploying a new contract. -It should be noted that the `did:algo` spec will work with any contract that implements the ABI interface defined in [the ARC4 JSON description](./contracts/artifacts/AlgoDID.arc4.json) and the `did:algo` [spec](../SPEC.md). +It should be noted that the `did:algo` spec will work with any contract that implements the ABI interface defined in [the ARC4 JSON description](./contracts/artifacts/DIDAlgoStorage.arc4.json) and the `did:algo` [spec](../SPEC.md). ## Tests -Tests for the contract can be found at [here](./__test__/algo-did.test.ts). +Tests for the contract can be found at [here](./__test__/did-algo-storage.test.ts). ## Interacting With Contract diff --git a/reference_contract/__test__/algo-did.test.ts b/reference_contract/__test__/did-algo-storage.test.ts similarity index 98% rename from reference_contract/__test__/algo-did.test.ts rename to reference_contract/__test__/did-algo-storage.test.ts index 60854b5..b6adeb2 100644 --- a/reference_contract/__test__/algo-did.test.ts +++ b/reference_contract/__test__/did-algo-storage.test.ts @@ -7,7 +7,7 @@ import { } from '@jest/globals'; import algosdk from 'algosdk'; import { algodClient, kmdClient } from './common'; -import appSpec from '../contracts/artifacts/AlgoDID.json'; +import appSpec from '../contracts/artifacts/DIDAlgoStorage.arc32.json'; import { resolveDID, uploadDIDDocument, deleteDIDDocument, updateDIDDocument, } from '../src/index'; diff --git a/reference_contract/contracts/artifacts/AlgoDID.abi.json b/reference_contract/contracts/artifacts/AlgoDID.abi.json deleted file mode 100644 index a62273e..0000000 --- a/reference_contract/contracts/artifacts/AlgoDID.abi.json +++ /dev/null @@ -1,143 +0,0 @@ -{ - "name": "AlgoDID", - "desc": "", - "methods": [ - { - "name": "startUpload", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The pubkey of the DID" - }, - { - "name": "numBoxes", - "type": "uint64", - "desc": "The number of boxes that the data will take up" - }, - { - "name": "endBoxSize", - "type": "uint64", - "desc": "The size of the last box" - }, - { - "name": "mbrPayment", - "type": "pay", - "desc": "Payment from the uploader to cover the box MBR" - } - ], - "desc": "Allocate boxes to begin data upload process", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "upload", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The pubkey of the DID" - }, - { - "name": "boxIndex", - "type": "uint64", - "desc": "The index of the box to upload the given chunk of data to" - }, - { - "name": "offset", - "type": "uint64", - "desc": "The offset within the box to start writing the data" - }, - { - "name": "data", - "type": "byte[]", - "desc": "The data to write" - } - ], - "desc": "Upload data to a specific offset in a box", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "finishUpload", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The address of the DID" - } - ], - "desc": "Mark uploading as false", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "startDelete", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The address of the DID" - } - ], - "desc": "Starts the deletion process for the data associated with a DID", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "deleteData", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The address of the DID" - }, - { - "name": "boxIndex", - "type": "uint64", - "desc": "The index of the box to delete" - } - ], - "desc": "Deletes a box of data", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "updateApplication", - "args": [], - "desc": "Allow the contract to be updated by the creator", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "dummy", - "args": [], - "desc": "Dummy function to add extra box references for deleteData.Boxes are 32k, but a single app call can only inlcude enough references to read/write 8kat a time. Thus when a box is deleted, we need to add additional dummy calls with boxreferences to increase the total read/write budget to 32k.", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "createApplication", - "desc": "", - "returns": { - "type": "void", - "desc": "" - }, - "args": [] - } - ] -} \ No newline at end of file diff --git a/reference_contract/contracts/artifacts/AlgoDID.arc32.json b/reference_contract/contracts/artifacts/AlgoDID.arc32.json deleted file mode 100644 index 9d43dc9..0000000 --- a/reference_contract/contracts/artifacts/AlgoDID.arc32.json +++ /dev/null @@ -1,214 +0,0 @@ -{ - "hints": { - "startUpload(address,uint64,uint64,pay)void": { - "call_config": { - "no_op": "CALL" - } - }, - "upload(address,uint64,uint64,byte[])void": { - "call_config": { - "no_op": "CALL" - } - }, - "finishUpload(address)void": { - "call_config": { - "no_op": "CALL" - } - }, - "startDelete(address)void": { - "call_config": { - "no_op": "CALL" - } - }, - "deleteData(address,uint64)void": { - "call_config": { - "no_op": "CALL" - } - }, - "updateApplication()void": { - "call_config": { - "update_application": "CALL" - } - }, - "dummy()void": { - "call_config": { - "no_op": "CALL" - } - }, - "createApplication()void": { - "call_config": { - "no_op": "CREATE" - } - } - }, - "bare_call_config": { - "no_op": "NEVER", - "opt_in": "NEVER", - "close_out": "NEVER", - "update_application": "NEVER", - "delete_application": "NEVER" - }, - "schema": { - "local": { - "declared": {}, - "reserved": {} - }, - "global": { - "declared": { - "currentIndex": { - "type": "uint64", - "key": "currentIndex" - } - }, - "reserved": {} - } - }, - "state": { - "global": { - "num_byte_slices": 0, - "num_uints": 1 - }, - "local": { - "num_byte_slices": 0, - "num_uints": 0 - } - }, - "source": { - "approval": "#pragma version 10

// This TEAL was generated by TEALScript v0.96.0
// https://github.com/algorandfoundation/TEALScript

// This contract is compliant with and/or implements the following ARCs: [ ARC4 ]

// The following ten lines of TEAL handle initial program flow
// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed
// Here, action refers to the OnComplete in combination with whether the app is being created or called
// Every possible action for this contract is represented in the switch statement
// If the action is not implemented in the contract, its respective branch will be "*NOT_IMPLEMENTED" which just contains "err"
txn ApplicationID
!
int 6
*
txn OnCompletion
+
switch *call_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *call_UpdateApplication *NOT_IMPLEMENTED *create_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED

*NOT_IMPLEMENTED:
	// The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?
	err

// startUpload(address,uint64,uint64,pay)void
*abi_route_startUpload:
	// mbrPayment: pay
	txn GroupIndex
	int 1
	-
	dup
	gtxns TypeEnum
	int pay
	==

	// argument 0 (mbrPayment) for startUpload must be a pay transaction
	assert

	// endBoxSize: uint64
	txna ApplicationArgs 3
	btoi

	// numBoxes: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 3 (pubKey) for startUpload must be a address
	assert

	// execute startUpload(address,uint64,uint64,pay)void
	callsub startUpload
	int 1
	return

// startUpload(pubKey: Address, numBoxes: uint64, endBoxSize: uint64, mbrPayment: PayTxn): void
//
//
// Allocate boxes to begin data upload process
//
// @param pubKey The pubkey of the DID
// @param numBoxes The number of boxes that the data will take up
// @param endBoxSize The size of the last box
// @param mbrPayment Payment from the uploader to cover the box MBR
startUpload:
	proto 4 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x
	dupn 3

	// contracts/algo-did.algo.ts:63
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:65
	// startBox = this.currentIndex.value
	byte 0x63757272656e74496e646578 // "currentIndex"
	app_global_get
	frame_bury 0 // startBox: uint64

	// contracts/algo-did.algo.ts:66
	// endBox = startBox + numBoxes - 1
	frame_dig 0 // startBox: uint64
	frame_dig -2 // numBoxes: uint64
	+
	int 1
	-
	frame_bury 1 // endBox: uint64

	// contracts/algo-did.algo.ts:68
	// metadata: Metadata = {
	//       start: startBox, end: endBox, status: UPLOADING, endSize: endBoxSize, lastDeleted: 0,
	//     }
	frame_dig 0 // startBox: uint64
	itob
	frame_dig 1 // endBox: uint64
	itob
	concat
	byte 0x00
	concat
	frame_dig -3 // endBoxSize: uint64
	itob
	concat
	byte 0x0000000000000000
	concat
	frame_bury 2 // metadata: Metadata

	// contracts/algo-did.algo.ts:72
	// assert(!this.metadata(pubKey).exists)
	frame_dig -1 // pubKey: Address
	box_len
	swap
	pop
	!
	assert

	// contracts/algo-did.algo.ts:74
	// this.metadata(pubKey).value = metadata
	frame_dig -1 // pubKey: Address
	frame_dig 2 // metadata: Metadata
	box_put

	// contracts/algo-did.algo.ts:76
	// this.currentIndex.value = endBox + 1
	byte 0x63757272656e74496e646578 // "currentIndex"
	frame_dig 1 // endBox: uint64
	int 1
	+
	app_global_put

	// contracts/algo-did.algo.ts:78
	// totalCost = numBoxes * COST_PER_BOX // cost of data boxes
	//     + (numBoxes - 1) * MAX_BOX_SIZE * COST_PER_BYTE // cost of data
	//     + numBoxes * 8 * COST_PER_BYTE // cost of data keys
	//     + endBoxSize * COST_PER_BYTE // cost of last data box
	//     + COST_PER_BOX + (8 + 8 + 1 + 8 + 32 + 8) * COST_PER_BYTE
	frame_dig -2 // numBoxes: uint64
	int 2500
	*
	frame_dig -2 // numBoxes: uint64
	int 1
	-
	int 32768
	*
	int 400
	*
	+
	frame_dig -2 // numBoxes: uint64
	int 8
	*
	int 400
	*
	+
	frame_dig -3 // endBoxSize: uint64
	int 400
	*
	+
	int 2500
	+
	int 26000
	+
	frame_bury 3 // totalCost: uint64

	// contracts/algo-did.algo.ts:84
	// assert(mbrPayment.amount === totalCost)
	frame_dig -4 // mbrPayment: PayTxn
	gtxns Amount
	frame_dig 3 // totalCost: uint64
	==
	assert

	// contracts/algo-did.algo.ts:85
	// assert(mbrPayment.receiver === this.app.address)
	frame_dig -4 // mbrPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==
	assert
	retsub

// upload(address,uint64,uint64,byte[])void
*abi_route_upload:
	// data: byte[]
	txna ApplicationArgs 4
	extract 2 0

	// offset: uint64
	txna ApplicationArgs 3
	btoi

	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 3 (pubKey) for upload must be a address
	assert

	// execute upload(address,uint64,uint64,byte[])void
	callsub upload
	int 1
	return

// upload(pubKey: Address, boxIndex: uint64, offset: uint64, data: bytes): void
//
//
// Upload data to a specific offset in a box
//
// @param pubKey The pubkey of the DID
// @param boxIndex The index of the box to upload the given chunk of data to
// @param offset The offset within the box to start writing the data
// @param data The data to write
upload:
	proto 4 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x

	// contracts/algo-did.algo.ts:98
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:100
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: Address
	frame_bury 0 // storage key//metadata

	// contracts/algo-did.algo.ts:101
	// assert(metadata.status === UPLOADING)
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	int 1
	box_extract
	btoi
	int 0
	==
	assert

	// contracts/algo-did.algo.ts:102
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -1 // pubKey: Address
	int 0
	int 8
	box_extract
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz *skip_and0
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	<=
	&&

*skip_and0:
	assert

	// *if0_condition
	// contracts/algo-did.algo.ts:104
	// offset === 0
	frame_dig -3 // offset: uint64
	int 0
	==
	bz *if0_end

	// *if0_consequent
	// contracts/algo-did.algo.ts:105
	// this.dataBoxes(boxIndex).create(boxIndex === metadata.end ? metadata.endSize : MAX_BOX_SIZE)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	==
	bz *ternary0_false
	frame_dig -1 // pubKey: Address
	int 17 // headOffset
	int 8
	box_extract
	btoi
	b *ternary0_end

*ternary0_false:
	int 32768

*ternary0_end:
	box_create
	pop

*if0_end:
	// contracts/algo-did.algo.ts:108
	// this.dataBoxes(boxIndex).replace(offset, data)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -3 // offset: uint64
	frame_dig -4 // data: bytes
	box_replace
	retsub

// finishUpload(address)void
*abi_route_finishUpload:
	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 0 (pubKey) for finishUpload must be a address
	assert

	// execute finishUpload(address)void
	callsub finishUpload
	int 1
	return

// finishUpload(pubKey: Address): void
//
//
// Mark uploading as false
//
// @param pubKey The address of the DID
finishUpload:
	proto 1 0

	// contracts/algo-did.algo.ts:118
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:120
	// this.metadata(pubKey).value.status = READY
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	byte 0x01
	box_replace
	retsub

// startDelete(address)void
*abi_route_startDelete:
	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 0 (pubKey) for startDelete must be a address
	assert

	// execute startDelete(address)void
	callsub startDelete
	int 1
	return

// startDelete(pubKey: Address): void
//
// Starts the deletion process for the data associated with a DID
//
// @param pubKey The address of the DID
startDelete:
	proto 1 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x

	// contracts/algo-did.algo.ts:129
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:131
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: Address
	frame_bury 0 // storage key//metadata

	// contracts/algo-did.algo.ts:132
	// assert(metadata.status === READY)
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	int 1
	box_extract
	btoi
	int 1
	==
	assert

	// contracts/algo-did.algo.ts:134
	// metadata.status = DELETING
	frame_dig 0 // storage key//metadata
	int 16 // headOffset
	byte 0x02
	box_replace
	retsub

// deleteData(address,uint64)void
*abi_route_deleteData:
	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 1 (pubKey) for deleteData must be a address
	assert

	// execute deleteData(address,uint64)void
	callsub deleteData
	int 1
	return

// deleteData(pubKey: Address, boxIndex: uint64): void
//
// Deletes a box of data
//
// @param pubKey The address of the DID
// @param boxIndex The index of the box to delete
deleteData:
	proto 2 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x
	dup

	// contracts/algo-did.algo.ts:144
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:146
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: Address
	frame_bury 0 // storage key//metadata

	// contracts/algo-did.algo.ts:147
	// assert(metadata.status === DELETING)
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	int 1
	box_extract
	btoi
	int 2
	==
	assert

	// contracts/algo-did.algo.ts:148
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -1 // pubKey: Address
	int 0
	int 8
	box_extract
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz *skip_and1
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	<=
	&&

*skip_and1:
	assert

	// *if1_condition
	// contracts/algo-did.algo.ts:150
	// boxIndex !== metadata.start
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 0
	int 8
	box_extract
	btoi
	!=
	bz *if1_end

	// *if1_consequent
	// contracts/algo-did.algo.ts:150
	// assert(metadata.lastDeleted === boxIndex - 1)
	frame_dig -1 // pubKey: Address
	int 25 // headOffset
	int 8
	box_extract
	btoi
	frame_dig -2 // boxIndex: uint64
	int 1
	-
	==
	assert

*if1_end:
	// contracts/algo-did.algo.ts:152
	// preMBR = globals.currentApplicationAddress.minBalance
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	pop
	frame_bury 1 // preMBR: uint64

	// contracts/algo-did.algo.ts:154
	// this.dataBoxes(boxIndex).delete()
	frame_dig -2 // boxIndex: uint64
	itob
	box_del

	// *if2_condition
	// contracts/algo-did.algo.ts:156
	// boxIndex === metadata.end
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	==
	bz *if2_else

	// *if2_consequent
	// contracts/algo-did.algo.ts:156
	// this.metadata(pubKey).delete()
	frame_dig -1 // pubKey: Address
	box_del
	b *if2_end

*if2_else:
	// contracts/algo-did.algo.ts:157
	// metadata.lastDeleted = boxIndex
	int 25 // headOffset
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig 0 // storage key//metadata
	cover 2
	box_replace

*if2_end:
	// contracts/algo-did.algo.ts:159
	// sendPayment({
	//       amount: preMBR - globals.currentApplicationAddress.minBalance,
	//       receiver: this.txn.sender,
	//     })
	itxn_begin
	int pay
	itxn_field TypeEnum

	// contracts/algo-did.algo.ts:160
	// amount: preMBR - globals.currentApplicationAddress.minBalance
	frame_dig 1 // preMBR: uint64
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	pop
	-
	itxn_field Amount

	// contracts/algo-did.algo.ts:161
	// receiver: this.txn.sender
	txn Sender
	itxn_field Receiver

	// Fee field not set, defaulting to 0
	int 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// updateApplication()void
*abi_route_updateApplication:
	// execute updateApplication()void
	callsub updateApplication
	int 1
	return

// updateApplication(): void
//
// Allow the contract to be updated by the creator
updateApplication:
	proto 0 0

	// contracts/algo-did.algo.ts:169
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert
	retsub

// dummy()void
*abi_route_dummy:
	// execute dummy()void
	callsub dummy
	int 1
	return

// dummy(): void
//
// Dummy function to add extra box references for deleteData.
// Boxes are 32k, but a single app call can only inlcude enough references to read/write 8k
// at a time. Thus when a box is deleted, we need to add additional dummy calls with box
// references to increase the total read/write budget to 32k.
dummy:
	proto 0 0
	retsub

*abi_route_createApplication:
	int 1
	return

*create_NoOp:
	method "createApplication()void"
	txna ApplicationArgs 0
	match *abi_route_createApplication

	// this contract does not implement the given ABI method for create NoOp
	err

*call_NoOp:
	method "startUpload(address,uint64,uint64,pay)void"
	method "upload(address,uint64,uint64,byte[])void"
	method "finishUpload(address)void"
	method "startDelete(address)void"
	method "deleteData(address,uint64)void"
	method "dummy()void"
	txna ApplicationArgs 0
	match *abi_route_startUpload *abi_route_upload *abi_route_finishUpload *abi_route_startDelete *abi_route_deleteData *abi_route_dummy

	// this contract does not implement the given ABI method for call NoOp
	err

*call_UpdateApplication:
	method "updateApplication()void"
	txna ApplicationArgs 0
	match *abi_route_updateApplication

	// this contract does not implement the given ABI method for call UpdateApplication
	err", - "clear": "I3ByYWdtYSB2ZXJzaW9uIDEw" - }, - "contract": { - "name": "AlgoDID", - "desc": "", - "methods": [ - { - "name": "startUpload", - "desc": "Allocate boxes to begin data upload process", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The pubkey of the DID" - }, - { - "name": "numBoxes", - "type": "uint64", - "desc": "The number of boxes that the data will take up" - }, - { - "name": "endBoxSize", - "type": "uint64", - "desc": "The size of the last box" - }, - { - "name": "mbrPayment", - "type": "pay", - "desc": "Payment from the uploader to cover the box MBR" - } - ], - "returns": { - "type": "void" - } - }, - { - "name": "upload", - "desc": "Upload data to a specific offset in a box", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The pubkey of the DID" - }, - { - "name": "boxIndex", - "type": "uint64", - "desc": "The index of the box to upload the given chunk of data to" - }, - { - "name": "offset", - "type": "uint64", - "desc": "The offset within the box to start writing the data" - }, - { - "name": "data", - "type": "byte[]", - "desc": "The data to write" - } - ], - "returns": { - "type": "void" - } - }, - { - "name": "finishUpload", - "desc": "Mark uploading as false", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The address of the DID" - } - ], - "returns": { - "type": "void" - } - }, - { - "name": "startDelete", - "desc": "Starts the deletion process for the data associated with a DID", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The address of the DID" - } - ], - "returns": { - "type": "void" - } - }, - { - "name": "deleteData", - "desc": "Deletes a box of data", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The address of the DID" - }, - { - "name": "boxIndex", - "type": "uint64", - "desc": "The index of the box to delete" - } - ], - "returns": { - "type": "void" - } - }, - { - "name": "updateApplication", - "desc": "Allow the contract to be updated by the creator", - "args": [], - "returns": { - "type": "void" - } - }, - { - "name": "dummy", - "desc": "Dummy function to add extra box references for deleteData.Boxes are 32k, but a single app call can only inlcude enough references to read/write 8kat a time. Thus when a box is deleted, we need to add additional dummy calls with boxreferences to increase the total read/write budget to 32k.", - "args": [], - "returns": { - "type": "void" - } - }, - { - "name": "createApplication", - "args": [], - "returns": { - "type": "void" - } - } - ] - } -} \ No newline at end of file diff --git a/reference_contract/contracts/artifacts/AlgoDID.json b/reference_contract/contracts/artifacts/AlgoDID.json deleted file mode 100644 index a3317c5..0000000 --- a/reference_contract/contracts/artifacts/AlgoDID.json +++ /dev/null @@ -1,223 +0,0 @@ -{ - "hints": { - "startUpload(address,uint64,uint64,pay)void": { - "call_config": { - "no_op": "CALL" - } - }, - "upload(address,uint64,uint64,byte[])void": { - "call_config": { - "no_op": "CALL" - } - }, - "finishUpload(address)void": { - "call_config": { - "no_op": "CALL" - } - }, - "startDelete(address)void": { - "call_config": { - "no_op": "CALL" - } - }, - "deleteData(address,uint64)void": { - "call_config": { - "no_op": "CALL" - } - }, - "updateApplication()void": { - "call_config": { - "update_application": "CALL" - } - }, - "dummy()void": { - "call_config": { - "no_op": "CALL" - } - }, - "createApplication()void": { - "call_config": { - "no_op": "CREATE" - } - } - }, - "bare_call_config": { - "no_op": "NEVER", - "opt_in": "NEVER", - "close_out": "NEVER", - "update_application": "NEVER", - "delete_application": "NEVER" - }, - "schema": { - "local": { - "declared": {}, - "reserved": {} - }, - "global": { - "declared": { - "currentIndex": { - "type": "uint64", - "key": "currentIndex" - } - }, - "reserved": {} - } - }, - "state": { - "global": { - "num_byte_slices": 0, - "num_uints": 1 - }, - "local": { - "num_byte_slices": 0, - "num_uints": 0 - } - }, - "source": { - "approval": "#pragma version 9

// This TEAL was generated by TEALScript v0.51.1
// https://github.com/algorand-devrel/TEALScript

// This contract is compliant with and/or implements the following ARCs: [ ARC4 ]

// The following ten lines of TEAL handle initial program flow
// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed
// Here, action refers to the OnComplete in combination with whether the app is being created or called
// Every possible action for this contract is represented in the switch statement
// If the action is not implmented in the contract, its repsective branch will be "NOT_IMPLMENTED" which just contains "err"
txn ApplicationID
int 0
>
int 6
*
txn OnCompletion
+
switch create_NoOp NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED call_NoOp NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED call_UpdateApplication

NOT_IMPLEMENTED:
	err

// startUpload(pay,uint64,uint64,address)void
//
// 
// Allocate boxes to begin data upload process
// 
// @param pubKey The pubkey of the DID
// @param numBoxes The number of boxes that the data will take up
// @param endBoxSize The size of the last box
// @param mbrPayment Payment from the uploader to cover the box MBR
abi_route_startUpload:
	byte 0x; dupn 3 // push empty bytes to fill the stack frame for this subroutine's local variables

	// mbrPayment: pay
	txn GroupIndex
	int 1
	-
	dup
	gtxns TypeEnum
	int pay
	==
	assert

	// endBoxSize: uint64
	txna ApplicationArgs 3
	btoi

	// numBoxes: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute startUpload(pay,uint64,uint64,address)void
	callsub startUpload
	int 1
	return

startUpload:
	proto 8 0

	// contracts/algo-did.algo.ts:64
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:66
	// startBox = this.currentIndex.value
	byte 0x63757272656e74496e646578 // "currentIndex"
	app_global_get
	frame_bury -5 // startBox: uint64

	// contracts/algo-did.algo.ts:67
	// endBox = startBox + numBoxes - 1
	frame_dig -5 // startBox: uint64
	frame_dig -2 // numBoxes: uint64
	+
	int 1
	-
	frame_bury -6 // endBox: uint64

	// contracts/algo-did.algo.ts:69
	// metadata: Metadata = {
	//       start: startBox, end: endBox, status: UPLOADING, endSize: endBoxSize, lastDeleted: 0,
	//     }
	frame_dig -5 // startBox: uint64
	itob
	frame_dig -6 // endBox: uint64
	itob
	concat
	byte 0x00
	byte 0x00
	bitlen
	int 8
	<=
	assert
	byte 0xFF
	b&
	concat
	frame_dig -3 // endBoxSize: uint64
	itob
	concat
	byte 0x0000000000000000
	concat
	frame_bury -7 // metadata: Metadata

	// contracts/algo-did.algo.ts:73
	// assert(!this.metadata(pubKey).exists)
	frame_dig -1 // pubKey: address
	box_len
	swap
	pop
	!
	assert

	// contracts/algo-did.algo.ts:75
	// this.metadata(pubKey).value = metadata
	frame_dig -1 // pubKey: address
	frame_dig -7 // metadata: Metadata
	box_put

	// contracts/algo-did.algo.ts:77
	// this.currentIndex.value = endBox + 1
	byte 0x63757272656e74496e646578 // "currentIndex"
	frame_dig -6 // endBox: uint64
	int 1
	+
	app_global_put

	// contracts/algo-did.algo.ts:79
	// totalCost = numBoxes * COST_PER_BOX // cost of data boxes
	//     + (numBoxes - 1) * MAX_BOX_SIZE * COST_PER_BYTE // cost of data
	//     + numBoxes * 8 * COST_PER_BYTE // cost of data keys
	//     + endBoxSize * COST_PER_BYTE // cost of last data box
	//     + COST_PER_BOX + (8 + 8 + 1 + 8 + 32 + 8) * COST_PER_BYTE
	frame_dig -2 // numBoxes: uint64
	int 2500
	*
	frame_dig -2 // numBoxes: uint64
	int 1
	-
	int 32768
	*
	int 400
	*
	+
	frame_dig -2 // numBoxes: uint64
	int 8
	*
	int 400
	*
	+
	frame_dig -3 // endBoxSize: uint64
	int 400
	*
	+
	int 2500
	+
	int 26000
	+
	frame_bury -8 // totalCost: uint64

	// contracts/algo-did.algo.ts:85
	// assert(mbrPayment.amount === totalCost)
	frame_dig -4 // mbrPayment: pay
	gtxns Amount
	frame_dig -8 // totalCost: uint64
	==
	assert

	// contracts/algo-did.algo.ts:86
	// assert(mbrPayment.receiver === this.app.address)
	frame_dig -4 // mbrPayment: pay
	gtxns Receiver
	global CurrentApplicationAddress
	==
	assert
	retsub

// upload(bytes,uint64,uint64,address)void
//
// 
// Upload data to a specific offset in a box
// 
// @param pubKey The pubkey of the DID
// @param boxIndex The index of the box to upload the given chunk of data to
// @param offset The offset within the box to start writing the data
// @param data The data to write
abi_route_upload:
	byte 0x // push empty bytes to fill the stack frame for this subroutine's local variables

	// data: byte[]
	txna ApplicationArgs 4
	extract 2 0

	// offset: uint64
	txna ApplicationArgs 3
	btoi

	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute upload(bytes,uint64,uint64,address)void
	callsub upload
	int 1
	return

upload:
	proto 5 0

	// contracts/algo-did.algo.ts:99
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:101
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: address
	frame_bury -5 // storage key//metadata

	// contracts/algo-did.algo.ts:102
	// assert(metadata.status === UPLOADING)
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 16 1
	byte 0x0000000000000000
	b==
	assert

	// contracts/algo-did.algo.ts:103
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 0 8
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz skip_and0
	frame_dig -2 // boxIndex: uint64
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 8 8
	btoi
	<=
	&&

skip_and0:
	assert

	// if0_condition
	// contracts/algo-did.algo.ts:105
	// offset === 0
	frame_dig -3 // offset: uint64
	int 0
	==
	bz if0_end

	// if0_consequent
	// contracts/algo-did.algo.ts:106
	// this.dataBoxes(boxIndex).create(boxIndex === metadata.end ? metadata.endSize : MAX_BOX_SIZE)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -2 // boxIndex: uint64
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 8 8
	btoi
	==
	bz ternary0_false
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 17 8
	btoi
	b ternary0_end

ternary0_false:
	int 32768

ternary0_end:
	box_create

if0_end:
	// contracts/algo-did.algo.ts:109
	// this.dataBoxes(boxIndex).replace(offset, data)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -3 // offset: uint64
	frame_dig -4 // data: bytes
	box_replace
	retsub

// finishUpload(address)void
//
// 
// Mark uploading as false
// 
// @param pubKey The address of the DID
abi_route_finishUpload:
	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute finishUpload(address)void
	callsub finishUpload
	int 1
	return

finishUpload:
	proto 1 0

	// contracts/algo-did.algo.ts:119
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:121
	// this.metadata(pubKey).value.status = READY
	frame_dig -1 // pubKey: address
	int 16
	byte 0x01
	box_replace
	retsub

// startDelete(address)void
//
// Starts the deletion process for the data associated with a DID
// 
// @param pubKey The address of the DID
abi_route_startDelete:
	byte 0x // push empty bytes to fill the stack frame for this subroutine's local variables

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute startDelete(address)void
	callsub startDelete
	int 1
	return

startDelete:
	proto 2 0

	// contracts/algo-did.algo.ts:130
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:132
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: address
	frame_bury -2 // storage key//metadata

	// contracts/algo-did.algo.ts:133
	// assert(metadata.status === READY)
	frame_dig -2 // storage key//metadata
	box_get
	assert
	extract 16 1
	byte 0x0000000000000001
	b==
	assert

	// contracts/algo-did.algo.ts:135
	// metadata.status = DELETING
	frame_dig -2 // storage key//metadata
	box_get
	assert
	byte 0x02
	replace2 16
	frame_dig -2 // storage key//metadata
	swap
	box_put
	retsub

// deleteData(uint64,address)void
//
// Deletes a box of data
// 
// @param pubKey The address of the DID
// @param boxIndex The index of the box to delete
abi_route_deleteData:
	byte 0x; dup // push empty bytes to fill the stack frame for this subroutine's local variables

	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute deleteData(uint64,address)void
	callsub deleteData
	int 1
	return

deleteData:
	proto 4 0

	// contracts/algo-did.algo.ts:145
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:147
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: address
	frame_bury -3 // storage key//metadata

	// contracts/algo-did.algo.ts:148
	// assert(metadata.status === DELETING)
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 16 1
	byte 0x0000000000000002
	b==
	assert

	// contracts/algo-did.algo.ts:149
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 0 8
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz skip_and1
	frame_dig -2 // boxIndex: uint64
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 8 8
	btoi
	<=
	&&

skip_and1:
	assert

	// if1_condition
	// contracts/algo-did.algo.ts:151
	// boxIndex !== metadata.start
	frame_dig -2 // boxIndex: uint64
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 0 8
	btoi
	!=
	bz if1_end

	// if1_consequent
	// contracts/algo-did.algo.ts:151
	// assert(metadata.lastDeleted === boxIndex - 1)
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 25 8
	btoi
	frame_dig -2 // boxIndex: uint64
	int 1
	-
	==
	assert

if1_end:
	// contracts/algo-did.algo.ts:153
	// preMBR = globals.currentApplicationAddress.minBalance
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	assert
	frame_bury -4 // preMBR: uint64

	// contracts/algo-did.algo.ts:155
	// this.dataBoxes(boxIndex).delete()
	frame_dig -2 // boxIndex: uint64
	itob
	box_del

	// if2_condition
	// contracts/algo-did.algo.ts:157
	// boxIndex === metadata.end
	frame_dig -2 // boxIndex: uint64
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 8 8
	btoi
	==
	bz if2_else

	// if2_consequent
	// contracts/algo-did.algo.ts:157
	// this.metadata(pubKey).delete()
	frame_dig -1 // pubKey: address
	box_del
	b if2_end

if2_else:
	// contracts/algo-did.algo.ts:158
	// metadata.lastDeleted = boxIndex
	frame_dig -3 // storage key//metadata
	box_get
	assert
	frame_dig -2 // boxIndex: uint64
	itob
	replace2 25
	frame_dig -3 // storage key//metadata
	swap
	box_put

if2_end:
	// contracts/algo-did.algo.ts:160
	// sendPayment({
	//       amount: preMBR - globals.currentApplicationAddress.minBalance,
	//       receiver: this.txn.sender,
	//     })
	itxn_begin
	int pay
	itxn_field TypeEnum

	// contracts/algo-did.algo.ts:161
	// amount: preMBR - globals.currentApplicationAddress.minBalance
	frame_dig -4 // preMBR: uint64
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	assert
	-
	itxn_field Amount

	// contracts/algo-did.algo.ts:162
	// receiver: this.txn.sender
	txn Sender
	itxn_field Receiver

	// Fee field not set, defaulting to 0
	int 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// updateApplication()void
//
// Allow the contract to be updated by the creator
abi_route_updateApplication:
	// execute updateApplication()void
	callsub updateApplication
	int 1
	return

updateApplication:
	proto 0 0

	// contracts/algo-did.algo.ts:170
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert
	retsub

// dummy()void
//
// Dummy function to add extra box references for deleteData.
// Boxes are 32k, but a single app call can only inlcude enough references to read/write 8k
// at a time. Thus when a box is deleted, we need to add additional dummy calls with box
// references to increase the total read/write budget to 32k.
abi_route_dummy:
	// execute dummy()void
	callsub dummy
	int 1
	return

dummy:
	proto 0 0
	retsub

abi_route_createApplication:
	int 1
	return

create_NoOp:
	method "createApplication()void"
	txna ApplicationArgs 0
	match abi_route_createApplication
	err

call_NoOp:
	method "startUpload(address,uint64,uint64,pay)void"
	method "upload(address,uint64,uint64,byte[])void"
	method "finishUpload(address)void"
	method "startDelete(address)void"
	method "deleteData(address,uint64)void"
	method "dummy()void"
	txna ApplicationArgs 0
	match abi_route_startUpload abi_route_upload abi_route_finishUpload abi_route_startDelete abi_route_deleteData abi_route_dummy
	err

call_UpdateApplication:
	method "updateApplication()void"
	txna ApplicationArgs 0
	match abi_route_updateApplication
	err", - "clear": "I3ByYWdtYSB2ZXJzaW9uIDkKaW50IDE=" - }, - "contract": { - "name": "AlgoDID", - "desc": "", - "methods": [ - { - "name": "startUpload", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The pubkey of the DID" - }, - { - "name": "numBoxes", - "type": "uint64", - "desc": "The number of boxes that the data will take up" - }, - { - "name": "endBoxSize", - "type": "uint64", - "desc": "The size of the last box" - }, - { - "name": "mbrPayment", - "type": "pay", - "desc": "Payment from the uploader to cover the box MBR" - } - ], - "desc": "Allocate boxes to begin data upload process", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "upload", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The pubkey of the DID" - }, - { - "name": "boxIndex", - "type": "uint64", - "desc": "The index of the box to upload the given chunk of data to" - }, - { - "name": "offset", - "type": "uint64", - "desc": "The offset within the box to start writing the data" - }, - { - "name": "data", - "type": "byte[]", - "desc": "The data to write" - } - ], - "desc": "Upload data to a specific offset in a box", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "finishUpload", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The address of the DID" - } - ], - "desc": "Mark uploading as false", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "startDelete", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The address of the DID" - } - ], - "desc": "Starts the deletion process for the data associated with a DID", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "deleteData", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The address of the DID" - }, - { - "name": "boxIndex", - "type": "uint64", - "desc": "The index of the box to delete" - } - ], - "desc": "Deletes a box of data", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "updateApplication", - "args": [], - "desc": "Allow the contract to be updated by the creator", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "dummy", - "args": [], - "desc": "Dummy function to add extra box references for deleteData.Boxes are 32k, but a single app call can only inlcude enough references to read/write 8kat a time. Thus when a box is deleted, we need to add additional dummy calls with boxreferences to increase the total read/write budget to 32k.", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "createApplication", - "desc": "", - "returns": { - "type": "void", - "desc": "" - }, - "args": [] - } - ] - } -} \ No newline at end of file diff --git a/reference_contract/contracts/artifacts/AlgoDID.approval.teal b/reference_contract/contracts/artifacts/DIDAlgoStorage.approval.teal similarity index 88% rename from reference_contract/contracts/artifacts/AlgoDID.approval.teal rename to reference_contract/contracts/artifacts/DIDAlgoStorage.approval.teal index a9cdc96..186e5cc 100644 --- a/reference_contract/contracts/artifacts/AlgoDID.approval.teal +++ b/reference_contract/contracts/artifacts/DIDAlgoStorage.approval.teal @@ -75,20 +75,20 @@ startUpload: byte 0x dupn 3 - // contracts/algo-did.algo.ts:63 + // contracts/did-algo-storage.algo.ts:63 // assert(this.txn.sender === globals.creatorAddress) txn Sender global CreatorAddress == assert - // contracts/algo-did.algo.ts:65 + // contracts/did-algo-storage.algo.ts:65 // startBox = this.currentIndex.value byte 0x63757272656e74496e646578 // "currentIndex" app_global_get frame_bury 0 // startBox: uint64 - // contracts/algo-did.algo.ts:66 + // contracts/did-algo-storage.algo.ts:66 // endBox = startBox + numBoxes - 1 frame_dig 0 // startBox: uint64 frame_dig -2 // numBoxes: uint64 @@ -97,7 +97,7 @@ startUpload: - frame_bury 1 // endBox: uint64 - // contracts/algo-did.algo.ts:68 + // contracts/did-algo-storage.algo.ts:68 // metadata: Metadata = { // start: startBox, end: endBox, status: UPLOADING, endSize: endBoxSize, lastDeleted: 0, // } @@ -115,7 +115,7 @@ startUpload: concat frame_bury 2 // metadata: Metadata - // contracts/algo-did.algo.ts:72 + // contracts/did-algo-storage.algo.ts:72 // assert(!this.metadata(pubKey).exists) frame_dig -1 // pubKey: Address box_len @@ -124,13 +124,13 @@ startUpload: ! assert - // contracts/algo-did.algo.ts:74 + // contracts/did-algo-storage.algo.ts:74 // this.metadata(pubKey).value = metadata frame_dig -1 // pubKey: Address frame_dig 2 // metadata: Metadata box_put - // contracts/algo-did.algo.ts:76 + // contracts/did-algo-storage.algo.ts:76 // this.currentIndex.value = endBox + 1 byte 0x63757272656e74496e646578 // "currentIndex" frame_dig 1 // endBox: uint64 @@ -138,7 +138,7 @@ startUpload: + app_global_put - // contracts/algo-did.algo.ts:78 + // contracts/did-algo-storage.algo.ts:78 // totalCost = numBoxes * COST_PER_BOX // cost of data boxes // + (numBoxes - 1) * MAX_BOX_SIZE * COST_PER_BYTE // cost of data // + numBoxes * 8 * COST_PER_BYTE // cost of data keys @@ -171,7 +171,7 @@ startUpload: + frame_bury 3 // totalCost: uint64 - // contracts/algo-did.algo.ts:84 + // contracts/did-algo-storage.algo.ts:84 // assert(mbrPayment.amount === totalCost) frame_dig -4 // mbrPayment: PayTxn gtxns Amount @@ -179,7 +179,7 @@ startUpload: == assert - // contracts/algo-did.algo.ts:85 + // contracts/did-algo-storage.algo.ts:85 // assert(mbrPayment.receiver === this.app.address) frame_dig -4 // mbrPayment: PayTxn gtxns Receiver @@ -232,19 +232,19 @@ upload: // Push empty bytes after the frame pointer to reserve space for local variables byte 0x - // contracts/algo-did.algo.ts:98 + // contracts/did-algo-storage.algo.ts:98 // assert(this.txn.sender === globals.creatorAddress) txn Sender global CreatorAddress == assert - // contracts/algo-did.algo.ts:100 + // contracts/did-algo-storage.algo.ts:100 // metadata = this.metadata(pubKey).value frame_dig -1 // pubKey: Address frame_bury 0 // storage key//metadata - // contracts/algo-did.algo.ts:101 + // contracts/did-algo-storage.algo.ts:101 // assert(metadata.status === UPLOADING) frame_dig -1 // pubKey: Address int 16 // headOffset @@ -255,7 +255,7 @@ upload: == assert - // contracts/algo-did.algo.ts:102 + // contracts/did-algo-storage.algo.ts:102 // assert(metadata.start <= boxIndex && boxIndex <= metadata.end) frame_dig -1 // pubKey: Address int 0 @@ -279,7 +279,7 @@ upload: assert // *if0_condition - // contracts/algo-did.algo.ts:104 + // contracts/did-algo-storage.algo.ts:104 // offset === 0 frame_dig -3 // offset: uint64 int 0 @@ -287,7 +287,7 @@ upload: bz *if0_end // *if0_consequent - // contracts/algo-did.algo.ts:105 + // contracts/did-algo-storage.algo.ts:105 // this.dataBoxes(boxIndex).create(boxIndex === metadata.end ? metadata.endSize : MAX_BOX_SIZE) frame_dig -2 // boxIndex: uint64 itob @@ -314,7 +314,7 @@ upload: pop *if0_end: - // contracts/algo-did.algo.ts:108 + // contracts/did-algo-storage.algo.ts:108 // this.dataBoxes(boxIndex).replace(offset, data) frame_dig -2 // boxIndex: uint64 itob @@ -349,14 +349,14 @@ upload: finishUpload: proto 1 0 - // contracts/algo-did.algo.ts:118 + // contracts/did-algo-storage.algo.ts:118 // assert(this.txn.sender === globals.creatorAddress) txn Sender global CreatorAddress == assert - // contracts/algo-did.algo.ts:120 + // contracts/did-algo-storage.algo.ts:120 // this.metadata(pubKey).value.status = READY frame_dig -1 // pubKey: Address int 16 // headOffset @@ -392,19 +392,19 @@ startDelete: // Push empty bytes after the frame pointer to reserve space for local variables byte 0x - // contracts/algo-did.algo.ts:129 + // contracts/did-algo-storage.algo.ts:129 // assert(this.txn.sender === globals.creatorAddress) txn Sender global CreatorAddress == assert - // contracts/algo-did.algo.ts:131 + // contracts/did-algo-storage.algo.ts:131 // metadata = this.metadata(pubKey).value frame_dig -1 // pubKey: Address frame_bury 0 // storage key//metadata - // contracts/algo-did.algo.ts:132 + // contracts/did-algo-storage.algo.ts:132 // assert(metadata.status === READY) frame_dig -1 // pubKey: Address int 16 // headOffset @@ -415,7 +415,7 @@ startDelete: == assert - // contracts/algo-did.algo.ts:134 + // contracts/did-algo-storage.algo.ts:134 // metadata.status = DELETING frame_dig 0 // storage key//metadata int 16 // headOffset @@ -457,19 +457,19 @@ deleteData: byte 0x dup - // contracts/algo-did.algo.ts:144 + // contracts/did-algo-storage.algo.ts:144 // assert(this.txn.sender === globals.creatorAddress) txn Sender global CreatorAddress == assert - // contracts/algo-did.algo.ts:146 + // contracts/did-algo-storage.algo.ts:146 // metadata = this.metadata(pubKey).value frame_dig -1 // pubKey: Address frame_bury 0 // storage key//metadata - // contracts/algo-did.algo.ts:147 + // contracts/did-algo-storage.algo.ts:147 // assert(metadata.status === DELETING) frame_dig -1 // pubKey: Address int 16 // headOffset @@ -480,7 +480,7 @@ deleteData: == assert - // contracts/algo-did.algo.ts:148 + // contracts/did-algo-storage.algo.ts:148 // assert(metadata.start <= boxIndex && boxIndex <= metadata.end) frame_dig -1 // pubKey: Address int 0 @@ -504,7 +504,7 @@ deleteData: assert // *if1_condition - // contracts/algo-did.algo.ts:150 + // contracts/did-algo-storage.algo.ts:150 // boxIndex !== metadata.start frame_dig -2 // boxIndex: uint64 frame_dig -1 // pubKey: Address @@ -516,7 +516,7 @@ deleteData: bz *if1_end // *if1_consequent - // contracts/algo-did.algo.ts:150 + // contracts/did-algo-storage.algo.ts:150 // assert(metadata.lastDeleted === boxIndex - 1) frame_dig -1 // pubKey: Address int 25 // headOffset @@ -530,21 +530,21 @@ deleteData: assert *if1_end: - // contracts/algo-did.algo.ts:152 + // contracts/did-algo-storage.algo.ts:152 // preMBR = globals.currentApplicationAddress.minBalance global CurrentApplicationAddress acct_params_get AcctMinBalance pop frame_bury 1 // preMBR: uint64 - // contracts/algo-did.algo.ts:154 + // contracts/did-algo-storage.algo.ts:154 // this.dataBoxes(boxIndex).delete() frame_dig -2 // boxIndex: uint64 itob box_del // *if2_condition - // contracts/algo-did.algo.ts:156 + // contracts/did-algo-storage.algo.ts:156 // boxIndex === metadata.end frame_dig -2 // boxIndex: uint64 frame_dig -1 // pubKey: Address @@ -556,14 +556,14 @@ deleteData: bz *if2_else // *if2_consequent - // contracts/algo-did.algo.ts:156 + // contracts/did-algo-storage.algo.ts:156 // this.metadata(pubKey).delete() frame_dig -1 // pubKey: Address box_del b *if2_end *if2_else: - // contracts/algo-did.algo.ts:157 + // contracts/did-algo-storage.algo.ts:157 // metadata.lastDeleted = boxIndex int 25 // headOffset frame_dig -2 // boxIndex: uint64 @@ -573,7 +573,7 @@ deleteData: box_replace *if2_end: - // contracts/algo-did.algo.ts:159 + // contracts/did-algo-storage.algo.ts:159 // sendPayment({ // amount: preMBR - globals.currentApplicationAddress.minBalance, // receiver: this.txn.sender, @@ -582,7 +582,7 @@ deleteData: int pay itxn_field TypeEnum - // contracts/algo-did.algo.ts:160 + // contracts/did-algo-storage.algo.ts:160 // amount: preMBR - globals.currentApplicationAddress.minBalance frame_dig 1 // preMBR: uint64 global CurrentApplicationAddress @@ -591,7 +591,7 @@ deleteData: - itxn_field Amount - // contracts/algo-did.algo.ts:161 + // contracts/did-algo-storage.algo.ts:161 // receiver: this.txn.sender txn Sender itxn_field Receiver @@ -617,7 +617,7 @@ deleteData: updateApplication: proto 0 0 - // contracts/algo-did.algo.ts:169 + // contracts/did-algo-storage.algo.ts:169 // assert(this.txn.sender === globals.creatorAddress) txn Sender global CreatorAddress diff --git a/reference_contract/contracts/artifacts/DIDAlgoStorage.arc32.json b/reference_contract/contracts/artifacts/DIDAlgoStorage.arc32.json new file mode 100644 index 0000000..c72c61e --- /dev/null +++ b/reference_contract/contracts/artifacts/DIDAlgoStorage.arc32.json @@ -0,0 +1,214 @@ +{ + "hints": { + "startUpload(address,uint64,uint64,pay)void": { + "call_config": { + "no_op": "CALL" + } + }, + "upload(address,uint64,uint64,byte[])void": { + "call_config": { + "no_op": "CALL" + } + }, + "finishUpload(address)void": { + "call_config": { + "no_op": "CALL" + } + }, + "startDelete(address)void": { + "call_config": { + "no_op": "CALL" + } + }, + "deleteData(address,uint64)void": { + "call_config": { + "no_op": "CALL" + } + }, + "updateApplication()void": { + "call_config": { + "update_application": "CALL" + } + }, + "dummy()void": { + "call_config": { + "no_op": "CALL" + } + }, + "createApplication()void": { + "call_config": { + "no_op": "CREATE" + } + } + }, + "bare_call_config": { + "no_op": "NEVER", + "opt_in": "NEVER", + "close_out": "NEVER", + "update_application": "NEVER", + "delete_application": "NEVER" + }, + "schema": { + "local": { + "declared": {}, + "reserved": {} + }, + "global": { + "declared": { + "currentIndex": { + "type": "uint64", + "key": "currentIndex" + } + }, + "reserved": {} + } + }, + "state": { + "global": { + "num_byte_slices": 0, + "num_uints": 1 + }, + "local": { + "num_byte_slices": 0, + "num_uints": 0 + } + }, + "source": { + "approval": "#pragma version 10

// This TEAL was generated by TEALScript v0.96.0
// https://github.com/algorandfoundation/TEALScript

// This contract is compliant with and/or implements the following ARCs: [ ARC4 ]

// The following ten lines of TEAL handle initial program flow
// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed
// Here, action refers to the OnComplete in combination with whether the app is being created or called
// Every possible action for this contract is represented in the switch statement
// If the action is not implemented in the contract, its respective branch will be "*NOT_IMPLEMENTED" which just contains "err"
txn ApplicationID
!
int 6
*
txn OnCompletion
+
switch *call_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *call_UpdateApplication *NOT_IMPLEMENTED *create_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED

*NOT_IMPLEMENTED:
	// The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?
	err

// startUpload(address,uint64,uint64,pay)void
*abi_route_startUpload:
	// mbrPayment: pay
	txn GroupIndex
	int 1
	-
	dup
	gtxns TypeEnum
	int pay
	==

	// argument 0 (mbrPayment) for startUpload must be a pay transaction
	assert

	// endBoxSize: uint64
	txna ApplicationArgs 3
	btoi

	// numBoxes: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 3 (pubKey) for startUpload must be a address
	assert

	// execute startUpload(address,uint64,uint64,pay)void
	callsub startUpload
	int 1
	return

// startUpload(pubKey: Address, numBoxes: uint64, endBoxSize: uint64, mbrPayment: PayTxn): void
//
//
// Allocate boxes to begin data upload process
//
// @param pubKey The pubkey of the DID
// @param numBoxes The number of boxes that the data will take up
// @param endBoxSize The size of the last box
// @param mbrPayment Payment from the uploader to cover the box MBR
startUpload:
	proto 4 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x
	dupn 3

	// contracts/did-algo-storage.algo.ts:63
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/did-algo-storage.algo.ts:65
	// startBox = this.currentIndex.value
	byte 0x63757272656e74496e646578 // "currentIndex"
	app_global_get
	frame_bury 0 // startBox: uint64

	// contracts/did-algo-storage.algo.ts:66
	// endBox = startBox + numBoxes - 1
	frame_dig 0 // startBox: uint64
	frame_dig -2 // numBoxes: uint64
	+
	int 1
	-
	frame_bury 1 // endBox: uint64

	// contracts/did-algo-storage.algo.ts:68
	// metadata: Metadata = {
	//       start: startBox, end: endBox, status: UPLOADING, endSize: endBoxSize, lastDeleted: 0,
	//     }
	frame_dig 0 // startBox: uint64
	itob
	frame_dig 1 // endBox: uint64
	itob
	concat
	byte 0x00
	concat
	frame_dig -3 // endBoxSize: uint64
	itob
	concat
	byte 0x0000000000000000
	concat
	frame_bury 2 // metadata: Metadata

	// contracts/did-algo-storage.algo.ts:72
	// assert(!this.metadata(pubKey).exists)
	frame_dig -1 // pubKey: Address
	box_len
	swap
	pop
	!
	assert

	// contracts/did-algo-storage.algo.ts:74
	// this.metadata(pubKey).value = metadata
	frame_dig -1 // pubKey: Address
	frame_dig 2 // metadata: Metadata
	box_put

	// contracts/did-algo-storage.algo.ts:76
	// this.currentIndex.value = endBox + 1
	byte 0x63757272656e74496e646578 // "currentIndex"
	frame_dig 1 // endBox: uint64
	int 1
	+
	app_global_put

	// contracts/did-algo-storage.algo.ts:78
	// totalCost = numBoxes * COST_PER_BOX // cost of data boxes
	//     + (numBoxes - 1) * MAX_BOX_SIZE * COST_PER_BYTE // cost of data
	//     + numBoxes * 8 * COST_PER_BYTE // cost of data keys
	//     + endBoxSize * COST_PER_BYTE // cost of last data box
	//     + COST_PER_BOX + (8 + 8 + 1 + 8 + 32 + 8) * COST_PER_BYTE
	frame_dig -2 // numBoxes: uint64
	int 2500
	*
	frame_dig -2 // numBoxes: uint64
	int 1
	-
	int 32768
	*
	int 400
	*
	+
	frame_dig -2 // numBoxes: uint64
	int 8
	*
	int 400
	*
	+
	frame_dig -3 // endBoxSize: uint64
	int 400
	*
	+
	int 2500
	+
	int 26000
	+
	frame_bury 3 // totalCost: uint64

	// contracts/did-algo-storage.algo.ts:84
	// assert(mbrPayment.amount === totalCost)
	frame_dig -4 // mbrPayment: PayTxn
	gtxns Amount
	frame_dig 3 // totalCost: uint64
	==
	assert

	// contracts/did-algo-storage.algo.ts:85
	// assert(mbrPayment.receiver === this.app.address)
	frame_dig -4 // mbrPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==
	assert
	retsub

// upload(address,uint64,uint64,byte[])void
*abi_route_upload:
	// data: byte[]
	txna ApplicationArgs 4
	extract 2 0

	// offset: uint64
	txna ApplicationArgs 3
	btoi

	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 3 (pubKey) for upload must be a address
	assert

	// execute upload(address,uint64,uint64,byte[])void
	callsub upload
	int 1
	return

// upload(pubKey: Address, boxIndex: uint64, offset: uint64, data: bytes): void
//
//
// Upload data to a specific offset in a box
//
// @param pubKey The pubkey of the DID
// @param boxIndex The index of the box to upload the given chunk of data to
// @param offset The offset within the box to start writing the data
// @param data The data to write
upload:
	proto 4 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x

	// contracts/did-algo-storage.algo.ts:98
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/did-algo-storage.algo.ts:100
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: Address
	frame_bury 0 // storage key//metadata

	// contracts/did-algo-storage.algo.ts:101
	// assert(metadata.status === UPLOADING)
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	int 1
	box_extract
	btoi
	int 0
	==
	assert

	// contracts/did-algo-storage.algo.ts:102
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -1 // pubKey: Address
	int 0
	int 8
	box_extract
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz *skip_and0
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	<=
	&&

*skip_and0:
	assert

	// *if0_condition
	// contracts/did-algo-storage.algo.ts:104
	// offset === 0
	frame_dig -3 // offset: uint64
	int 0
	==
	bz *if0_end

	// *if0_consequent
	// contracts/did-algo-storage.algo.ts:105
	// this.dataBoxes(boxIndex).create(boxIndex === metadata.end ? metadata.endSize : MAX_BOX_SIZE)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	==
	bz *ternary0_false
	frame_dig -1 // pubKey: Address
	int 17 // headOffset
	int 8
	box_extract
	btoi
	b *ternary0_end

*ternary0_false:
	int 32768

*ternary0_end:
	box_create
	pop

*if0_end:
	// contracts/did-algo-storage.algo.ts:108
	// this.dataBoxes(boxIndex).replace(offset, data)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -3 // offset: uint64
	frame_dig -4 // data: bytes
	box_replace
	retsub

// finishUpload(address)void
*abi_route_finishUpload:
	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 0 (pubKey) for finishUpload must be a address
	assert

	// execute finishUpload(address)void
	callsub finishUpload
	int 1
	return

// finishUpload(pubKey: Address): void
//
//
// Mark uploading as false
//
// @param pubKey The address of the DID
finishUpload:
	proto 1 0

	// contracts/did-algo-storage.algo.ts:118
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/did-algo-storage.algo.ts:120
	// this.metadata(pubKey).value.status = READY
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	byte 0x01
	box_replace
	retsub

// startDelete(address)void
*abi_route_startDelete:
	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 0 (pubKey) for startDelete must be a address
	assert

	// execute startDelete(address)void
	callsub startDelete
	int 1
	return

// startDelete(pubKey: Address): void
//
// Starts the deletion process for the data associated with a DID
//
// @param pubKey The address of the DID
startDelete:
	proto 1 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x

	// contracts/did-algo-storage.algo.ts:129
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/did-algo-storage.algo.ts:131
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: Address
	frame_bury 0 // storage key//metadata

	// contracts/did-algo-storage.algo.ts:132
	// assert(metadata.status === READY)
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	int 1
	box_extract
	btoi
	int 1
	==
	assert

	// contracts/did-algo-storage.algo.ts:134
	// metadata.status = DELETING
	frame_dig 0 // storage key//metadata
	int 16 // headOffset
	byte 0x02
	box_replace
	retsub

// deleteData(address,uint64)void
*abi_route_deleteData:
	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 1 (pubKey) for deleteData must be a address
	assert

	// execute deleteData(address,uint64)void
	callsub deleteData
	int 1
	return

// deleteData(pubKey: Address, boxIndex: uint64): void
//
// Deletes a box of data
//
// @param pubKey The address of the DID
// @param boxIndex The index of the box to delete
deleteData:
	proto 2 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x
	dup

	// contracts/did-algo-storage.algo.ts:144
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/did-algo-storage.algo.ts:146
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: Address
	frame_bury 0 // storage key//metadata

	// contracts/did-algo-storage.algo.ts:147
	// assert(metadata.status === DELETING)
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	int 1
	box_extract
	btoi
	int 2
	==
	assert

	// contracts/did-algo-storage.algo.ts:148
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -1 // pubKey: Address
	int 0
	int 8
	box_extract
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz *skip_and1
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	<=
	&&

*skip_and1:
	assert

	// *if1_condition
	// contracts/did-algo-storage.algo.ts:150
	// boxIndex !== metadata.start
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 0
	int 8
	box_extract
	btoi
	!=
	bz *if1_end

	// *if1_consequent
	// contracts/did-algo-storage.algo.ts:150
	// assert(metadata.lastDeleted === boxIndex - 1)
	frame_dig -1 // pubKey: Address
	int 25 // headOffset
	int 8
	box_extract
	btoi
	frame_dig -2 // boxIndex: uint64
	int 1
	-
	==
	assert

*if1_end:
	// contracts/did-algo-storage.algo.ts:152
	// preMBR = globals.currentApplicationAddress.minBalance
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	pop
	frame_bury 1 // preMBR: uint64

	// contracts/did-algo-storage.algo.ts:154
	// this.dataBoxes(boxIndex).delete()
	frame_dig -2 // boxIndex: uint64
	itob
	box_del

	// *if2_condition
	// contracts/did-algo-storage.algo.ts:156
	// boxIndex === metadata.end
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	==
	bz *if2_else

	// *if2_consequent
	// contracts/did-algo-storage.algo.ts:156
	// this.metadata(pubKey).delete()
	frame_dig -1 // pubKey: Address
	box_del
	b *if2_end

*if2_else:
	// contracts/did-algo-storage.algo.ts:157
	// metadata.lastDeleted = boxIndex
	int 25 // headOffset
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig 0 // storage key//metadata
	cover 2
	box_replace

*if2_end:
	// contracts/did-algo-storage.algo.ts:159
	// sendPayment({
	//       amount: preMBR - globals.currentApplicationAddress.minBalance,
	//       receiver: this.txn.sender,
	//     })
	itxn_begin
	int pay
	itxn_field TypeEnum

	// contracts/did-algo-storage.algo.ts:160
	// amount: preMBR - globals.currentApplicationAddress.minBalance
	frame_dig 1 // preMBR: uint64
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	pop
	-
	itxn_field Amount

	// contracts/did-algo-storage.algo.ts:161
	// receiver: this.txn.sender
	txn Sender
	itxn_field Receiver

	// Fee field not set, defaulting to 0
	int 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// updateApplication()void
*abi_route_updateApplication:
	// execute updateApplication()void
	callsub updateApplication
	int 1
	return

// updateApplication(): void
//
// Allow the contract to be updated by the creator
updateApplication:
	proto 0 0

	// contracts/did-algo-storage.algo.ts:169
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert
	retsub

// dummy()void
*abi_route_dummy:
	// execute dummy()void
	callsub dummy
	int 1
	return

// dummy(): void
//
// Dummy function to add extra box references for deleteData.
// Boxes are 32k, but a single app call can only inlcude enough references to read/write 8k
// at a time. Thus when a box is deleted, we need to add additional dummy calls with box
// references to increase the total read/write budget to 32k.
dummy:
	proto 0 0
	retsub

*abi_route_createApplication:
	int 1
	return

*create_NoOp:
	method "createApplication()void"
	txna ApplicationArgs 0
	match *abi_route_createApplication

	// this contract does not implement the given ABI method for create NoOp
	err

*call_NoOp:
	method "startUpload(address,uint64,uint64,pay)void"
	method "upload(address,uint64,uint64,byte[])void"
	method "finishUpload(address)void"
	method "startDelete(address)void"
	method "deleteData(address,uint64)void"
	method "dummy()void"
	txna ApplicationArgs 0
	match *abi_route_startUpload *abi_route_upload *abi_route_finishUpload *abi_route_startDelete *abi_route_deleteData *abi_route_dummy

	// this contract does not implement the given ABI method for call NoOp
	err

*call_UpdateApplication:
	method "updateApplication()void"
	txna ApplicationArgs 0
	match *abi_route_updateApplication

	// this contract does not implement the given ABI method for call UpdateApplication
	err", + "clear": "I3ByYWdtYSB2ZXJzaW9uIDEw" + }, + "contract": { + "name": "DIDAlgoStorage", + "desc": "", + "methods": [ + { + "name": "startUpload", + "desc": "Allocate boxes to begin data upload process", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The pubkey of the DID" + }, + { + "name": "numBoxes", + "type": "uint64", + "desc": "The number of boxes that the data will take up" + }, + { + "name": "endBoxSize", + "type": "uint64", + "desc": "The size of the last box" + }, + { + "name": "mbrPayment", + "type": "pay", + "desc": "Payment from the uploader to cover the box MBR" + } + ], + "returns": { + "type": "void" + } + }, + { + "name": "upload", + "desc": "Upload data to a specific offset in a box", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The pubkey of the DID" + }, + { + "name": "boxIndex", + "type": "uint64", + "desc": "The index of the box to upload the given chunk of data to" + }, + { + "name": "offset", + "type": "uint64", + "desc": "The offset within the box to start writing the data" + }, + { + "name": "data", + "type": "byte[]", + "desc": "The data to write" + } + ], + "returns": { + "type": "void" + } + }, + { + "name": "finishUpload", + "desc": "Mark uploading as false", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + } + ], + "returns": { + "type": "void" + } + }, + { + "name": "startDelete", + "desc": "Starts the deletion process for the data associated with a DID", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + } + ], + "returns": { + "type": "void" + } + }, + { + "name": "deleteData", + "desc": "Deletes a box of data", + "args": [ + { + "name": "pubKey", + "type": "address", + "desc": "The address of the DID" + }, + { + "name": "boxIndex", + "type": "uint64", + "desc": "The index of the box to delete" + } + ], + "returns": { + "type": "void" + } + }, + { + "name": "updateApplication", + "desc": "Allow the contract to be updated by the creator", + "args": [], + "returns": { + "type": "void" + } + }, + { + "name": "dummy", + "desc": "Dummy function to add extra box references for deleteData.Boxes are 32k, but a single app call can only inlcude enough references to read/write 8kat a time. Thus when a box is deleted, we need to add additional dummy calls with boxreferences to increase the total read/write budget to 32k.", + "args": [], + "returns": { + "type": "void" + } + }, + { + "name": "createApplication", + "args": [], + "returns": { + "type": "void" + } + } + ] + } +} \ No newline at end of file diff --git a/client/internal/contracts/AlgoDID.arc4.json b/reference_contract/contracts/artifacts/DIDAlgoStorage.arc4.json similarity index 99% rename from client/internal/contracts/AlgoDID.arc4.json rename to reference_contract/contracts/artifacts/DIDAlgoStorage.arc4.json index 59184cc..9fc6009 100644 --- a/client/internal/contracts/AlgoDID.arc4.json +++ b/reference_contract/contracts/artifacts/DIDAlgoStorage.arc4.json @@ -1,5 +1,5 @@ { - "name": "AlgoDID", + "name": "DIDAlgoStorage", "desc": "", "methods": [ { diff --git a/reference_contract/contracts/artifacts/AlgoDID.arc56_draft.json b/reference_contract/contracts/artifacts/DIDAlgoStorage.arc56_draft.json similarity index 75% rename from reference_contract/contracts/artifacts/AlgoDID.arc56_draft.json rename to reference_contract/contracts/artifacts/DIDAlgoStorage.arc56_draft.json index 497ad1a..3f017ac 100644 --- a/reference_contract/contracts/artifacts/AlgoDID.arc56_draft.json +++ b/reference_contract/contracts/artifacts/DIDAlgoStorage.arc56_draft.json @@ -1,5 +1,5 @@ { - "name": "AlgoDID", + "name": "DIDAlgoStorage", "desc": "", "methods": [ { @@ -3170,7 +3170,7 @@ } ], "source": { - "approval": "#pragma version 10

// This TEAL was generated by TEALScript v0.96.0
// https://github.com/algorandfoundation/TEALScript

// This contract is compliant with and/or implements the following ARCs: [ ARC4 ]

// The following ten lines of TEAL handle initial program flow
// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed
// Here, action refers to the OnComplete in combination with whether the app is being created or called
// Every possible action for this contract is represented in the switch statement
// If the action is not implemented in the contract, its respective branch will be "*NOT_IMPLEMENTED" which just contains "err"
txn ApplicationID
!
int 6
*
txn OnCompletion
+
switch *call_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *call_UpdateApplication *NOT_IMPLEMENTED *create_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED

*NOT_IMPLEMENTED:
	// The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?
	err

// startUpload(address,uint64,uint64,pay)void
*abi_route_startUpload:
	// mbrPayment: pay
	txn GroupIndex
	int 1
	-
	dup
	gtxns TypeEnum
	int pay
	==

	// argument 0 (mbrPayment) for startUpload must be a pay transaction
	assert

	// endBoxSize: uint64
	txna ApplicationArgs 3
	btoi

	// numBoxes: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 3 (pubKey) for startUpload must be a address
	assert

	// execute startUpload(address,uint64,uint64,pay)void
	callsub startUpload
	int 1
	return

// startUpload(pubKey: Address, numBoxes: uint64, endBoxSize: uint64, mbrPayment: PayTxn): void
//
//
// Allocate boxes to begin data upload process
//
// @param pubKey The pubkey of the DID
// @param numBoxes The number of boxes that the data will take up
// @param endBoxSize The size of the last box
// @param mbrPayment Payment from the uploader to cover the box MBR
startUpload:
	proto 4 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x
	dupn 3

	// contracts/algo-did.algo.ts:63
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:65
	// startBox = this.currentIndex.value
	byte 0x63757272656e74496e646578 // "currentIndex"
	app_global_get
	frame_bury 0 // startBox: uint64

	// contracts/algo-did.algo.ts:66
	// endBox = startBox + numBoxes - 1
	frame_dig 0 // startBox: uint64
	frame_dig -2 // numBoxes: uint64
	+
	int 1
	-
	frame_bury 1 // endBox: uint64

	// contracts/algo-did.algo.ts:68
	// metadata: Metadata = {
	//       start: startBox, end: endBox, status: UPLOADING, endSize: endBoxSize, lastDeleted: 0,
	//     }
	frame_dig 0 // startBox: uint64
	itob
	frame_dig 1 // endBox: uint64
	itob
	concat
	byte 0x00
	concat
	frame_dig -3 // endBoxSize: uint64
	itob
	concat
	byte 0x0000000000000000
	concat
	frame_bury 2 // metadata: Metadata

	// contracts/algo-did.algo.ts:72
	// assert(!this.metadata(pubKey).exists)
	frame_dig -1 // pubKey: Address
	box_len
	swap
	pop
	!
	assert

	// contracts/algo-did.algo.ts:74
	// this.metadata(pubKey).value = metadata
	frame_dig -1 // pubKey: Address
	frame_dig 2 // metadata: Metadata
	box_put

	// contracts/algo-did.algo.ts:76
	// this.currentIndex.value = endBox + 1
	byte 0x63757272656e74496e646578 // "currentIndex"
	frame_dig 1 // endBox: uint64
	int 1
	+
	app_global_put

	// contracts/algo-did.algo.ts:78
	// totalCost = numBoxes * COST_PER_BOX // cost of data boxes
	//     + (numBoxes - 1) * MAX_BOX_SIZE * COST_PER_BYTE // cost of data
	//     + numBoxes * 8 * COST_PER_BYTE // cost of data keys
	//     + endBoxSize * COST_PER_BYTE // cost of last data box
	//     + COST_PER_BOX + (8 + 8 + 1 + 8 + 32 + 8) * COST_PER_BYTE
	frame_dig -2 // numBoxes: uint64
	int 2500
	*
	frame_dig -2 // numBoxes: uint64
	int 1
	-
	int 32768
	*
	int 400
	*
	+
	frame_dig -2 // numBoxes: uint64
	int 8
	*
	int 400
	*
	+
	frame_dig -3 // endBoxSize: uint64
	int 400
	*
	+
	int 2500
	+
	int 26000
	+
	frame_bury 3 // totalCost: uint64

	// contracts/algo-did.algo.ts:84
	// assert(mbrPayment.amount === totalCost)
	frame_dig -4 // mbrPayment: PayTxn
	gtxns Amount
	frame_dig 3 // totalCost: uint64
	==
	assert

	// contracts/algo-did.algo.ts:85
	// assert(mbrPayment.receiver === this.app.address)
	frame_dig -4 // mbrPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==
	assert
	retsub

// upload(address,uint64,uint64,byte[])void
*abi_route_upload:
	// data: byte[]
	txna ApplicationArgs 4
	extract 2 0

	// offset: uint64
	txna ApplicationArgs 3
	btoi

	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 3 (pubKey) for upload must be a address
	assert

	// execute upload(address,uint64,uint64,byte[])void
	callsub upload
	int 1
	return

// upload(pubKey: Address, boxIndex: uint64, offset: uint64, data: bytes): void
//
//
// Upload data to a specific offset in a box
//
// @param pubKey The pubkey of the DID
// @param boxIndex The index of the box to upload the given chunk of data to
// @param offset The offset within the box to start writing the data
// @param data The data to write
upload:
	proto 4 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x

	// contracts/algo-did.algo.ts:98
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:100
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: Address
	frame_bury 0 // storage key//metadata

	// contracts/algo-did.algo.ts:101
	// assert(metadata.status === UPLOADING)
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	int 1
	box_extract
	btoi
	int 0
	==
	assert

	// contracts/algo-did.algo.ts:102
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -1 // pubKey: Address
	int 0
	int 8
	box_extract
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz *skip_and0
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	<=
	&&

*skip_and0:
	assert

	// *if0_condition
	// contracts/algo-did.algo.ts:104
	// offset === 0
	frame_dig -3 // offset: uint64
	int 0
	==
	bz *if0_end

	// *if0_consequent
	// contracts/algo-did.algo.ts:105
	// this.dataBoxes(boxIndex).create(boxIndex === metadata.end ? metadata.endSize : MAX_BOX_SIZE)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	==
	bz *ternary0_false
	frame_dig -1 // pubKey: Address
	int 17 // headOffset
	int 8
	box_extract
	btoi
	b *ternary0_end

*ternary0_false:
	int 32768

*ternary0_end:
	box_create
	pop

*if0_end:
	// contracts/algo-did.algo.ts:108
	// this.dataBoxes(boxIndex).replace(offset, data)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -3 // offset: uint64
	frame_dig -4 // data: bytes
	box_replace
	retsub

// finishUpload(address)void
*abi_route_finishUpload:
	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 0 (pubKey) for finishUpload must be a address
	assert

	// execute finishUpload(address)void
	callsub finishUpload
	int 1
	return

// finishUpload(pubKey: Address): void
//
//
// Mark uploading as false
//
// @param pubKey The address of the DID
finishUpload:
	proto 1 0

	// contracts/algo-did.algo.ts:118
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:120
	// this.metadata(pubKey).value.status = READY
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	byte 0x01
	box_replace
	retsub

// startDelete(address)void
*abi_route_startDelete:
	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 0 (pubKey) for startDelete must be a address
	assert

	// execute startDelete(address)void
	callsub startDelete
	int 1
	return

// startDelete(pubKey: Address): void
//
// Starts the deletion process for the data associated with a DID
//
// @param pubKey The address of the DID
startDelete:
	proto 1 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x

	// contracts/algo-did.algo.ts:129
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:131
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: Address
	frame_bury 0 // storage key//metadata

	// contracts/algo-did.algo.ts:132
	// assert(metadata.status === READY)
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	int 1
	box_extract
	btoi
	int 1
	==
	assert

	// contracts/algo-did.algo.ts:134
	// metadata.status = DELETING
	frame_dig 0 // storage key//metadata
	int 16 // headOffset
	byte 0x02
	box_replace
	retsub

// deleteData(address,uint64)void
*abi_route_deleteData:
	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 1 (pubKey) for deleteData must be a address
	assert

	// execute deleteData(address,uint64)void
	callsub deleteData
	int 1
	return

// deleteData(pubKey: Address, boxIndex: uint64): void
//
// Deletes a box of data
//
// @param pubKey The address of the DID
// @param boxIndex The index of the box to delete
deleteData:
	proto 2 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x
	dup

	// contracts/algo-did.algo.ts:144
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:146
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: Address
	frame_bury 0 // storage key//metadata

	// contracts/algo-did.algo.ts:147
	// assert(metadata.status === DELETING)
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	int 1
	box_extract
	btoi
	int 2
	==
	assert

	// contracts/algo-did.algo.ts:148
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -1 // pubKey: Address
	int 0
	int 8
	box_extract
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz *skip_and1
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	<=
	&&

*skip_and1:
	assert

	// *if1_condition
	// contracts/algo-did.algo.ts:150
	// boxIndex !== metadata.start
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 0
	int 8
	box_extract
	btoi
	!=
	bz *if1_end

	// *if1_consequent
	// contracts/algo-did.algo.ts:150
	// assert(metadata.lastDeleted === boxIndex - 1)
	frame_dig -1 // pubKey: Address
	int 25 // headOffset
	int 8
	box_extract
	btoi
	frame_dig -2 // boxIndex: uint64
	int 1
	-
	==
	assert

*if1_end:
	// contracts/algo-did.algo.ts:152
	// preMBR = globals.currentApplicationAddress.minBalance
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	pop
	frame_bury 1 // preMBR: uint64

	// contracts/algo-did.algo.ts:154
	// this.dataBoxes(boxIndex).delete()
	frame_dig -2 // boxIndex: uint64
	itob
	box_del

	// *if2_condition
	// contracts/algo-did.algo.ts:156
	// boxIndex === metadata.end
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	==
	bz *if2_else

	// *if2_consequent
	// contracts/algo-did.algo.ts:156
	// this.metadata(pubKey).delete()
	frame_dig -1 // pubKey: Address
	box_del
	b *if2_end

*if2_else:
	// contracts/algo-did.algo.ts:157
	// metadata.lastDeleted = boxIndex
	int 25 // headOffset
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig 0 // storage key//metadata
	cover 2
	box_replace

*if2_end:
	// contracts/algo-did.algo.ts:159
	// sendPayment({
	//       amount: preMBR - globals.currentApplicationAddress.minBalance,
	//       receiver: this.txn.sender,
	//     })
	itxn_begin
	int pay
	itxn_field TypeEnum

	// contracts/algo-did.algo.ts:160
	// amount: preMBR - globals.currentApplicationAddress.minBalance
	frame_dig 1 // preMBR: uint64
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	pop
	-
	itxn_field Amount

	// contracts/algo-did.algo.ts:161
	// receiver: this.txn.sender
	txn Sender
	itxn_field Receiver

	// Fee field not set, defaulting to 0
	int 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// updateApplication()void
*abi_route_updateApplication:
	// execute updateApplication()void
	callsub updateApplication
	int 1
	return

// updateApplication(): void
//
// Allow the contract to be updated by the creator
updateApplication:
	proto 0 0

	// contracts/algo-did.algo.ts:169
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert
	retsub

// dummy()void
*abi_route_dummy:
	// execute dummy()void
	callsub dummy
	int 1
	return

// dummy(): void
//
// Dummy function to add extra box references for deleteData.
// Boxes are 32k, but a single app call can only inlcude enough references to read/write 8k
// at a time. Thus when a box is deleted, we need to add additional dummy calls with box
// references to increase the total read/write budget to 32k.
dummy:
	proto 0 0
	retsub

*abi_route_createApplication:
	int 1
	return

*create_NoOp:
	method "createApplication()void"
	txna ApplicationArgs 0
	match *abi_route_createApplication

	// this contract does not implement the given ABI method for create NoOp
	err

*call_NoOp:
	method "startUpload(address,uint64,uint64,pay)void"
	method "upload(address,uint64,uint64,byte[])void"
	method "finishUpload(address)void"
	method "startDelete(address)void"
	method "deleteData(address,uint64)void"
	method "dummy()void"
	txna ApplicationArgs 0
	match *abi_route_startUpload *abi_route_upload *abi_route_finishUpload *abi_route_startDelete *abi_route_deleteData *abi_route_dummy

	// this contract does not implement the given ABI method for call NoOp
	err

*call_UpdateApplication:
	method "updateApplication()void"
	txna ApplicationArgs 0
	match *abi_route_updateApplication

	// this contract does not implement the given ABI method for call UpdateApplication
	err", + "approval": "#pragma version 10

// This TEAL was generated by TEALScript v0.96.0
// https://github.com/algorandfoundation/TEALScript

// This contract is compliant with and/or implements the following ARCs: [ ARC4 ]

// The following ten lines of TEAL handle initial program flow
// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed
// Here, action refers to the OnComplete in combination with whether the app is being created or called
// Every possible action for this contract is represented in the switch statement
// If the action is not implemented in the contract, its respective branch will be "*NOT_IMPLEMENTED" which just contains "err"
txn ApplicationID
!
int 6
*
txn OnCompletion
+
switch *call_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *call_UpdateApplication *NOT_IMPLEMENTED *create_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED

*NOT_IMPLEMENTED:
	// The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?
	err

// startUpload(address,uint64,uint64,pay)void
*abi_route_startUpload:
	// mbrPayment: pay
	txn GroupIndex
	int 1
	-
	dup
	gtxns TypeEnum
	int pay
	==

	// argument 0 (mbrPayment) for startUpload must be a pay transaction
	assert

	// endBoxSize: uint64
	txna ApplicationArgs 3
	btoi

	// numBoxes: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 3 (pubKey) for startUpload must be a address
	assert

	// execute startUpload(address,uint64,uint64,pay)void
	callsub startUpload
	int 1
	return

// startUpload(pubKey: Address, numBoxes: uint64, endBoxSize: uint64, mbrPayment: PayTxn): void
//
//
// Allocate boxes to begin data upload process
//
// @param pubKey The pubkey of the DID
// @param numBoxes The number of boxes that the data will take up
// @param endBoxSize The size of the last box
// @param mbrPayment Payment from the uploader to cover the box MBR
startUpload:
	proto 4 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x
	dupn 3

	// contracts/did-algo-storage.algo.ts:63
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/did-algo-storage.algo.ts:65
	// startBox = this.currentIndex.value
	byte 0x63757272656e74496e646578 // "currentIndex"
	app_global_get
	frame_bury 0 // startBox: uint64

	// contracts/did-algo-storage.algo.ts:66
	// endBox = startBox + numBoxes - 1
	frame_dig 0 // startBox: uint64
	frame_dig -2 // numBoxes: uint64
	+
	int 1
	-
	frame_bury 1 // endBox: uint64

	// contracts/did-algo-storage.algo.ts:68
	// metadata: Metadata = {
	//       start: startBox, end: endBox, status: UPLOADING, endSize: endBoxSize, lastDeleted: 0,
	//     }
	frame_dig 0 // startBox: uint64
	itob
	frame_dig 1 // endBox: uint64
	itob
	concat
	byte 0x00
	concat
	frame_dig -3 // endBoxSize: uint64
	itob
	concat
	byte 0x0000000000000000
	concat
	frame_bury 2 // metadata: Metadata

	// contracts/did-algo-storage.algo.ts:72
	// assert(!this.metadata(pubKey).exists)
	frame_dig -1 // pubKey: Address
	box_len
	swap
	pop
	!
	assert

	// contracts/did-algo-storage.algo.ts:74
	// this.metadata(pubKey).value = metadata
	frame_dig -1 // pubKey: Address
	frame_dig 2 // metadata: Metadata
	box_put

	// contracts/did-algo-storage.algo.ts:76
	// this.currentIndex.value = endBox + 1
	byte 0x63757272656e74496e646578 // "currentIndex"
	frame_dig 1 // endBox: uint64
	int 1
	+
	app_global_put

	// contracts/did-algo-storage.algo.ts:78
	// totalCost = numBoxes * COST_PER_BOX // cost of data boxes
	//     + (numBoxes - 1) * MAX_BOX_SIZE * COST_PER_BYTE // cost of data
	//     + numBoxes * 8 * COST_PER_BYTE // cost of data keys
	//     + endBoxSize * COST_PER_BYTE // cost of last data box
	//     + COST_PER_BOX + (8 + 8 + 1 + 8 + 32 + 8) * COST_PER_BYTE
	frame_dig -2 // numBoxes: uint64
	int 2500
	*
	frame_dig -2 // numBoxes: uint64
	int 1
	-
	int 32768
	*
	int 400
	*
	+
	frame_dig -2 // numBoxes: uint64
	int 8
	*
	int 400
	*
	+
	frame_dig -3 // endBoxSize: uint64
	int 400
	*
	+
	int 2500
	+
	int 26000
	+
	frame_bury 3 // totalCost: uint64

	// contracts/did-algo-storage.algo.ts:84
	// assert(mbrPayment.amount === totalCost)
	frame_dig -4 // mbrPayment: PayTxn
	gtxns Amount
	frame_dig 3 // totalCost: uint64
	==
	assert

	// contracts/did-algo-storage.algo.ts:85
	// assert(mbrPayment.receiver === this.app.address)
	frame_dig -4 // mbrPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==
	assert
	retsub

// upload(address,uint64,uint64,byte[])void
*abi_route_upload:
	// data: byte[]
	txna ApplicationArgs 4
	extract 2 0

	// offset: uint64
	txna ApplicationArgs 3
	btoi

	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 3 (pubKey) for upload must be a address
	assert

	// execute upload(address,uint64,uint64,byte[])void
	callsub upload
	int 1
	return

// upload(pubKey: Address, boxIndex: uint64, offset: uint64, data: bytes): void
//
//
// Upload data to a specific offset in a box
//
// @param pubKey The pubkey of the DID
// @param boxIndex The index of the box to upload the given chunk of data to
// @param offset The offset within the box to start writing the data
// @param data The data to write
upload:
	proto 4 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x

	// contracts/did-algo-storage.algo.ts:98
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/did-algo-storage.algo.ts:100
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: Address
	frame_bury 0 // storage key//metadata

	// contracts/did-algo-storage.algo.ts:101
	// assert(metadata.status === UPLOADING)
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	int 1
	box_extract
	btoi
	int 0
	==
	assert

	// contracts/did-algo-storage.algo.ts:102
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -1 // pubKey: Address
	int 0
	int 8
	box_extract
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz *skip_and0
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	<=
	&&

*skip_and0:
	assert

	// *if0_condition
	// contracts/did-algo-storage.algo.ts:104
	// offset === 0
	frame_dig -3 // offset: uint64
	int 0
	==
	bz *if0_end

	// *if0_consequent
	// contracts/did-algo-storage.algo.ts:105
	// this.dataBoxes(boxIndex).create(boxIndex === metadata.end ? metadata.endSize : MAX_BOX_SIZE)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	==
	bz *ternary0_false
	frame_dig -1 // pubKey: Address
	int 17 // headOffset
	int 8
	box_extract
	btoi
	b *ternary0_end

*ternary0_false:
	int 32768

*ternary0_end:
	box_create
	pop

*if0_end:
	// contracts/did-algo-storage.algo.ts:108
	// this.dataBoxes(boxIndex).replace(offset, data)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -3 // offset: uint64
	frame_dig -4 // data: bytes
	box_replace
	retsub

// finishUpload(address)void
*abi_route_finishUpload:
	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 0 (pubKey) for finishUpload must be a address
	assert

	// execute finishUpload(address)void
	callsub finishUpload
	int 1
	return

// finishUpload(pubKey: Address): void
//
//
// Mark uploading as false
//
// @param pubKey The address of the DID
finishUpload:
	proto 1 0

	// contracts/did-algo-storage.algo.ts:118
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/did-algo-storage.algo.ts:120
	// this.metadata(pubKey).value.status = READY
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	byte 0x01
	box_replace
	retsub

// startDelete(address)void
*abi_route_startDelete:
	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 0 (pubKey) for startDelete must be a address
	assert

	// execute startDelete(address)void
	callsub startDelete
	int 1
	return

// startDelete(pubKey: Address): void
//
// Starts the deletion process for the data associated with a DID
//
// @param pubKey The address of the DID
startDelete:
	proto 1 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x

	// contracts/did-algo-storage.algo.ts:129
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/did-algo-storage.algo.ts:131
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: Address
	frame_bury 0 // storage key//metadata

	// contracts/did-algo-storage.algo.ts:132
	// assert(metadata.status === READY)
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	int 1
	box_extract
	btoi
	int 1
	==
	assert

	// contracts/did-algo-storage.algo.ts:134
	// metadata.status = DELETING
	frame_dig 0 // storage key//metadata
	int 16 // headOffset
	byte 0x02
	box_replace
	retsub

// deleteData(address,uint64)void
*abi_route_deleteData:
	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==

	// argument 1 (pubKey) for deleteData must be a address
	assert

	// execute deleteData(address,uint64)void
	callsub deleteData
	int 1
	return

// deleteData(pubKey: Address, boxIndex: uint64): void
//
// Deletes a box of data
//
// @param pubKey The address of the DID
// @param boxIndex The index of the box to delete
deleteData:
	proto 2 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	byte 0x
	dup

	// contracts/did-algo-storage.algo.ts:144
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/did-algo-storage.algo.ts:146
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: Address
	frame_bury 0 // storage key//metadata

	// contracts/did-algo-storage.algo.ts:147
	// assert(metadata.status === DELETING)
	frame_dig -1 // pubKey: Address
	int 16 // headOffset
	int 1
	box_extract
	btoi
	int 2
	==
	assert

	// contracts/did-algo-storage.algo.ts:148
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -1 // pubKey: Address
	int 0
	int 8
	box_extract
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz *skip_and1
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	<=
	&&

*skip_and1:
	assert

	// *if1_condition
	// contracts/did-algo-storage.algo.ts:150
	// boxIndex !== metadata.start
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 0
	int 8
	box_extract
	btoi
	!=
	bz *if1_end

	// *if1_consequent
	// contracts/did-algo-storage.algo.ts:150
	// assert(metadata.lastDeleted === boxIndex - 1)
	frame_dig -1 // pubKey: Address
	int 25 // headOffset
	int 8
	box_extract
	btoi
	frame_dig -2 // boxIndex: uint64
	int 1
	-
	==
	assert

*if1_end:
	// contracts/did-algo-storage.algo.ts:152
	// preMBR = globals.currentApplicationAddress.minBalance
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	pop
	frame_bury 1 // preMBR: uint64

	// contracts/did-algo-storage.algo.ts:154
	// this.dataBoxes(boxIndex).delete()
	frame_dig -2 // boxIndex: uint64
	itob
	box_del

	// *if2_condition
	// contracts/did-algo-storage.algo.ts:156
	// boxIndex === metadata.end
	frame_dig -2 // boxIndex: uint64
	frame_dig -1 // pubKey: Address
	int 8 // headOffset
	int 8
	box_extract
	btoi
	==
	bz *if2_else

	// *if2_consequent
	// contracts/did-algo-storage.algo.ts:156
	// this.metadata(pubKey).delete()
	frame_dig -1 // pubKey: Address
	box_del
	b *if2_end

*if2_else:
	// contracts/did-algo-storage.algo.ts:157
	// metadata.lastDeleted = boxIndex
	int 25 // headOffset
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig 0 // storage key//metadata
	cover 2
	box_replace

*if2_end:
	// contracts/did-algo-storage.algo.ts:159
	// sendPayment({
	//       amount: preMBR - globals.currentApplicationAddress.minBalance,
	//       receiver: this.txn.sender,
	//     })
	itxn_begin
	int pay
	itxn_field TypeEnum

	// contracts/did-algo-storage.algo.ts:160
	// amount: preMBR - globals.currentApplicationAddress.minBalance
	frame_dig 1 // preMBR: uint64
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	pop
	-
	itxn_field Amount

	// contracts/did-algo-storage.algo.ts:161
	// receiver: this.txn.sender
	txn Sender
	itxn_field Receiver

	// Fee field not set, defaulting to 0
	int 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// updateApplication()void
*abi_route_updateApplication:
	// execute updateApplication()void
	callsub updateApplication
	int 1
	return

// updateApplication(): void
//
// Allow the contract to be updated by the creator
updateApplication:
	proto 0 0

	// contracts/did-algo-storage.algo.ts:169
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert
	retsub

// dummy()void
*abi_route_dummy:
	// execute dummy()void
	callsub dummy
	int 1
	return

// dummy(): void
//
// Dummy function to add extra box references for deleteData.
// Boxes are 32k, but a single app call can only inlcude enough references to read/write 8k
// at a time. Thus when a box is deleted, we need to add additional dummy calls with box
// references to increase the total read/write budget to 32k.
dummy:
	proto 0 0
	retsub

*abi_route_createApplication:
	int 1
	return

*create_NoOp:
	method "createApplication()void"
	txna ApplicationArgs 0
	match *abi_route_createApplication

	// this contract does not implement the given ABI method for create NoOp
	err

*call_NoOp:
	method "startUpload(address,uint64,uint64,pay)void"
	method "upload(address,uint64,uint64,byte[])void"
	method "finishUpload(address)void"
	method "startDelete(address)void"
	method "deleteData(address,uint64)void"
	method "dummy()void"
	txna ApplicationArgs 0
	match *abi_route_startUpload *abi_route_upload *abi_route_finishUpload *abi_route_startDelete *abi_route_deleteData *abi_route_dummy

	// this contract does not implement the given ABI method for call NoOp
	err

*call_UpdateApplication:
	method "updateApplication()void"
	txna ApplicationArgs 0
	match *abi_route_updateApplication

	// this contract does not implement the given ABI method for call UpdateApplication
	err", "clear": "I3ByYWdtYSB2ZXJzaW9uIDEw" }, "byteCode": { diff --git a/reference_contract/contracts/artifacts/AlgoDID.clear.teal b/reference_contract/contracts/artifacts/DIDAlgoStorage.clear.teal similarity index 100% rename from reference_contract/contracts/artifacts/AlgoDID.clear.teal rename to reference_contract/contracts/artifacts/DIDAlgoStorage.clear.teal diff --git a/reference_contract/contracts/artifacts/AlgoDID.src_map.json b/reference_contract/contracts/artifacts/DIDAlgoStorage.src_map.json similarity index 100% rename from reference_contract/contracts/artifacts/AlgoDID.src_map.json rename to reference_contract/contracts/artifacts/DIDAlgoStorage.src_map.json diff --git a/reference_contract/contracts/clients/AlgoDIDClient.ts b/reference_contract/contracts/clients/AlgoDIDClient.ts deleted file mode 100644 index e002a7c..0000000 --- a/reference_contract/contracts/clients/AlgoDIDClient.ts +++ /dev/null @@ -1,1047 +0,0 @@ -/* eslint-disable */ -/** - * This file was automatically generated by @algorandfoundation/algokit-client-generator. - * DO NOT MODIFY IT BY HAND. - * requires: @algorandfoundation/algokit-utils: ^2 - */ -import * as algokit from '@algorandfoundation/algokit-utils' -import { - AppCallTransactionResult, - AppCallTransactionResultOfType, - CoreAppCallArgs, - RawAppCallArgs, - AppState, - TealTemplateParams, - ABIAppCallArg, -} from '@algorandfoundation/algokit-utils/types/app' -import { - AppClientCallCoreParams, - AppClientCompilationParams, - AppClientDeployCoreParams, - AppDetails, - ApplicationClient, -} from '@algorandfoundation/algokit-utils/types/app-client' -import { AppSpec } from '@algorandfoundation/algokit-utils/types/app-spec' -import { SendTransactionResult, TransactionToSign, SendTransactionFrom } from '@algorandfoundation/algokit-utils/types/transaction' -import { Algodv2, OnApplicationComplete, Transaction, TransactionWithSigner, AtomicTransactionComposer } from 'algosdk' -export const APP_SPEC: AppSpec = { - "hints": { - "startUpload(address,uint64,uint64,pay)void": { - "call_config": { - "no_op": "CALL" - } - }, - "upload(address,uint64,uint64,byte[])void": { - "call_config": { - "no_op": "CALL" - } - }, - "finishUpload(address)void": { - "call_config": { - "no_op": "CALL" - } - }, - "startDelete(address)void": { - "call_config": { - "no_op": "CALL" - } - }, - "deleteData(address,uint64)void": { - "call_config": { - "no_op": "CALL" - } - }, - "updateApplication()void": { - "call_config": { - "update_application": "CALL" - } - }, - "dummy()void": { - "call_config": { - "no_op": "CALL" - } - }, - "createApplication()void": { - "call_config": { - "no_op": "CREATE" - } - } - }, - "bare_call_config": { - "no_op": "NEVER", - "opt_in": "NEVER", - "close_out": "NEVER", - "update_application": "NEVER", - "delete_application": "NEVER" - }, - "schema": { - "local": { - "declared": {}, - "reserved": {} - }, - "global": { - "declared": { - "currentIndex": { - "type": "uint64", - "key": "currentIndex" - } - }, - "reserved": {} - } - }, - "state": { - "global": { - "num_byte_slices": 0, - "num_uints": 1 - }, - "local": { - "num_byte_slices": 0, - "num_uints": 0 - } - }, - "source": { - "approval": "#pragma version 9

// This TEAL was generated by TEALScript v0.51.1
// https://github.com/algorand-devrel/TEALScript

// This contract is compliant with and/or implements the following ARCs: [ ARC4 ]

// The following ten lines of TEAL handle initial program flow
// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed
// Here, action refers to the OnComplete in combination with whether the app is being created or called
// Every possible action for this contract is represented in the switch statement
// If the action is not implmented in the contract, its repsective branch will be "NOT_IMPLMENTED" which just contains "err"
txn ApplicationID
int 0
>
int 6
*
txn OnCompletion
+
switch create_NoOp NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED call_NoOp NOT_IMPLEMENTED NOT_IMPLEMENTED NOT_IMPLEMENTED call_UpdateApplication

NOT_IMPLEMENTED:
	err

// startUpload(pay,uint64,uint64,address)void
//
// 
// Allocate boxes to begin data upload process
// 
// @param pubKey The pubkey of the DID
// @param numBoxes The number of boxes that the data will take up
// @param endBoxSize The size of the last box
// @param mbrPayment Payment from the uploader to cover the box MBR
abi_route_startUpload:
	byte 0x; dupn 3 // push empty bytes to fill the stack frame for this subroutine's local variables

	// mbrPayment: pay
	txn GroupIndex
	int 1
	-
	dup
	gtxns TypeEnum
	int pay
	==
	assert

	// endBoxSize: uint64
	txna ApplicationArgs 3
	btoi

	// numBoxes: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute startUpload(pay,uint64,uint64,address)void
	callsub startUpload
	int 1
	return

startUpload:
	proto 8 0

	// contracts/algo-did.algo.ts:64
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:66
	// startBox = this.currentIndex.value
	byte 0x63757272656e74496e646578 // "currentIndex"
	app_global_get
	frame_bury -5 // startBox: uint64

	// contracts/algo-did.algo.ts:67
	// endBox = startBox + numBoxes - 1
	frame_dig -5 // startBox: uint64
	frame_dig -2 // numBoxes: uint64
	+
	int 1
	-
	frame_bury -6 // endBox: uint64

	// contracts/algo-did.algo.ts:69
	// metadata: Metadata = {
	//       start: startBox, end: endBox, status: UPLOADING, endSize: endBoxSize, lastDeleted: 0,
	//     }
	frame_dig -5 // startBox: uint64
	itob
	frame_dig -6 // endBox: uint64
	itob
	concat
	byte 0x00
	byte 0x00
	bitlen
	int 8
	<=
	assert
	byte 0xFF
	b&
	concat
	frame_dig -3 // endBoxSize: uint64
	itob
	concat
	byte 0x0000000000000000
	concat
	frame_bury -7 // metadata: Metadata

	// contracts/algo-did.algo.ts:73
	// assert(!this.metadata(pubKey).exists)
	frame_dig -1 // pubKey: address
	box_len
	swap
	pop
	!
	assert

	// contracts/algo-did.algo.ts:75
	// this.metadata(pubKey).value = metadata
	frame_dig -1 // pubKey: address
	frame_dig -7 // metadata: Metadata
	box_put

	// contracts/algo-did.algo.ts:77
	// this.currentIndex.value = endBox + 1
	byte 0x63757272656e74496e646578 // "currentIndex"
	frame_dig -6 // endBox: uint64
	int 1
	+
	app_global_put

	// contracts/algo-did.algo.ts:79
	// totalCost = numBoxes * COST_PER_BOX // cost of data boxes
	//     + (numBoxes - 1) * MAX_BOX_SIZE * COST_PER_BYTE // cost of data
	//     + numBoxes * 8 * COST_PER_BYTE // cost of data keys
	//     + endBoxSize * COST_PER_BYTE // cost of last data box
	//     + COST_PER_BOX + (8 + 8 + 1 + 8 + 32 + 8) * COST_PER_BYTE
	frame_dig -2 // numBoxes: uint64
	int 2500
	*
	frame_dig -2 // numBoxes: uint64
	int 1
	-
	int 32768
	*
	int 400
	*
	+
	frame_dig -2 // numBoxes: uint64
	int 8
	*
	int 400
	*
	+
	frame_dig -3 // endBoxSize: uint64
	int 400
	*
	+
	int 2500
	+
	int 26000
	+
	frame_bury -8 // totalCost: uint64

	// contracts/algo-did.algo.ts:85
	// assert(mbrPayment.amount === totalCost)
	frame_dig -4 // mbrPayment: pay
	gtxns Amount
	frame_dig -8 // totalCost: uint64
	==
	assert

	// contracts/algo-did.algo.ts:86
	// assert(mbrPayment.receiver === this.app.address)
	frame_dig -4 // mbrPayment: pay
	gtxns Receiver
	global CurrentApplicationAddress
	==
	assert
	retsub

// upload(bytes,uint64,uint64,address)void
//
// 
// Upload data to a specific offset in a box
// 
// @param pubKey The pubkey of the DID
// @param boxIndex The index of the box to upload the given chunk of data to
// @param offset The offset within the box to start writing the data
// @param data The data to write
abi_route_upload:
	byte 0x // push empty bytes to fill the stack frame for this subroutine's local variables

	// data: byte[]
	txna ApplicationArgs 4
	extract 2 0

	// offset: uint64
	txna ApplicationArgs 3
	btoi

	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute upload(bytes,uint64,uint64,address)void
	callsub upload
	int 1
	return

upload:
	proto 5 0

	// contracts/algo-did.algo.ts:99
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:101
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: address
	frame_bury -5 // storage key//metadata

	// contracts/algo-did.algo.ts:102
	// assert(metadata.status === UPLOADING)
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 16 1
	byte 0x0000000000000000
	b==
	assert

	// contracts/algo-did.algo.ts:103
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 0 8
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz skip_and0
	frame_dig -2 // boxIndex: uint64
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 8 8
	btoi
	<=
	&&

skip_and0:
	assert

	// if0_condition
	// contracts/algo-did.algo.ts:105
	// offset === 0
	frame_dig -3 // offset: uint64
	int 0
	==
	bz if0_end

	// if0_consequent
	// contracts/algo-did.algo.ts:106
	// this.dataBoxes(boxIndex).create(boxIndex === metadata.end ? metadata.endSize : MAX_BOX_SIZE)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -2 // boxIndex: uint64
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 8 8
	btoi
	==
	bz ternary0_false
	frame_dig -5 // storage key//metadata
	box_get
	assert
	extract 17 8
	btoi
	b ternary0_end

ternary0_false:
	int 32768

ternary0_end:
	box_create

if0_end:
	// contracts/algo-did.algo.ts:109
	// this.dataBoxes(boxIndex).replace(offset, data)
	frame_dig -2 // boxIndex: uint64
	itob
	frame_dig -3 // offset: uint64
	frame_dig -4 // data: bytes
	box_replace
	retsub

// finishUpload(address)void
//
// 
// Mark uploading as false
// 
// @param pubKey The address of the DID
abi_route_finishUpload:
	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute finishUpload(address)void
	callsub finishUpload
	int 1
	return

finishUpload:
	proto 1 0

	// contracts/algo-did.algo.ts:119
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:121
	// this.metadata(pubKey).value.status = READY
	frame_dig -1 // pubKey: address
	int 16
	byte 0x01
	box_replace
	retsub

// startDelete(address)void
//
// Starts the deletion process for the data associated with a DID
// 
// @param pubKey The address of the DID
abi_route_startDelete:
	byte 0x // push empty bytes to fill the stack frame for this subroutine's local variables

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute startDelete(address)void
	callsub startDelete
	int 1
	return

startDelete:
	proto 2 0

	// contracts/algo-did.algo.ts:130
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:132
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: address
	frame_bury -2 // storage key//metadata

	// contracts/algo-did.algo.ts:133
	// assert(metadata.status === READY)
	frame_dig -2 // storage key//metadata
	box_get
	assert
	extract 16 1
	byte 0x0000000000000001
	b==
	assert

	// contracts/algo-did.algo.ts:135
	// metadata.status = DELETING
	frame_dig -2 // storage key//metadata
	box_get
	assert
	byte 0x02
	replace2 16
	frame_dig -2 // storage key//metadata
	swap
	box_put
	retsub

// deleteData(uint64,address)void
//
// Deletes a box of data
// 
// @param pubKey The address of the DID
// @param boxIndex The index of the box to delete
abi_route_deleteData:
	byte 0x; dup // push empty bytes to fill the stack frame for this subroutine's local variables

	// boxIndex: uint64
	txna ApplicationArgs 2
	btoi

	// pubKey: address
	txna ApplicationArgs 1
	dup
	len
	int 32
	==
	assert

	// execute deleteData(uint64,address)void
	callsub deleteData
	int 1
	return

deleteData:
	proto 4 0

	// contracts/algo-did.algo.ts:145
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert

	// contracts/algo-did.algo.ts:147
	// metadata = this.metadata(pubKey).value
	frame_dig -1 // pubKey: address
	frame_bury -3 // storage key//metadata

	// contracts/algo-did.algo.ts:148
	// assert(metadata.status === DELETING)
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 16 1
	byte 0x0000000000000002
	b==
	assert

	// contracts/algo-did.algo.ts:149
	// assert(metadata.start <= boxIndex && boxIndex <= metadata.end)
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 0 8
	btoi
	frame_dig -2 // boxIndex: uint64
	<=
	dup
	bz skip_and1
	frame_dig -2 // boxIndex: uint64
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 8 8
	btoi
	<=
	&&

skip_and1:
	assert

	// if1_condition
	// contracts/algo-did.algo.ts:151
	// boxIndex !== metadata.start
	frame_dig -2 // boxIndex: uint64
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 0 8
	btoi
	!=
	bz if1_end

	// if1_consequent
	// contracts/algo-did.algo.ts:151
	// assert(metadata.lastDeleted === boxIndex - 1)
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 25 8
	btoi
	frame_dig -2 // boxIndex: uint64
	int 1
	-
	==
	assert

if1_end:
	// contracts/algo-did.algo.ts:153
	// preMBR = globals.currentApplicationAddress.minBalance
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	assert
	frame_bury -4 // preMBR: uint64

	// contracts/algo-did.algo.ts:155
	// this.dataBoxes(boxIndex).delete()
	frame_dig -2 // boxIndex: uint64
	itob
	box_del

	// if2_condition
	// contracts/algo-did.algo.ts:157
	// boxIndex === metadata.end
	frame_dig -2 // boxIndex: uint64
	frame_dig -3 // storage key//metadata
	box_get
	assert
	extract 8 8
	btoi
	==
	bz if2_else

	// if2_consequent
	// contracts/algo-did.algo.ts:157
	// this.metadata(pubKey).delete()
	frame_dig -1 // pubKey: address
	box_del
	b if2_end

if2_else:
	// contracts/algo-did.algo.ts:158
	// metadata.lastDeleted = boxIndex
	frame_dig -3 // storage key//metadata
	box_get
	assert
	frame_dig -2 // boxIndex: uint64
	itob
	replace2 25
	frame_dig -3 // storage key//metadata
	swap
	box_put

if2_end:
	// contracts/algo-did.algo.ts:160
	// sendPayment({
	//       amount: preMBR - globals.currentApplicationAddress.minBalance,
	//       receiver: this.txn.sender,
	//     })
	itxn_begin
	int pay
	itxn_field TypeEnum

	// contracts/algo-did.algo.ts:161
	// amount: preMBR - globals.currentApplicationAddress.minBalance
	frame_dig -4 // preMBR: uint64
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	assert
	-
	itxn_field Amount

	// contracts/algo-did.algo.ts:162
	// receiver: this.txn.sender
	txn Sender
	itxn_field Receiver

	// Fee field not set, defaulting to 0
	int 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// updateApplication()void
//
// Allow the contract to be updated by the creator
abi_route_updateApplication:
	// execute updateApplication()void
	callsub updateApplication
	int 1
	return

updateApplication:
	proto 0 0

	// contracts/algo-did.algo.ts:170
	// assert(this.txn.sender === globals.creatorAddress)
	txn Sender
	global CreatorAddress
	==
	assert
	retsub

// dummy()void
//
// Dummy function to add extra box references for deleteData.
// Boxes are 32k, but a single app call can only inlcude enough references to read/write 8k
// at a time. Thus when a box is deleted, we need to add additional dummy calls with box
// references to increase the total read/write budget to 32k.
abi_route_dummy:
	// execute dummy()void
	callsub dummy
	int 1
	return

dummy:
	proto 0 0
	retsub

abi_route_createApplication:
	int 1
	return

create_NoOp:
	method "createApplication()void"
	txna ApplicationArgs 0
	match abi_route_createApplication
	err

call_NoOp:
	method "startUpload(address,uint64,uint64,pay)void"
	method "upload(address,uint64,uint64,byte[])void"
	method "finishUpload(address)void"
	method "startDelete(address)void"
	method "deleteData(address,uint64)void"
	method "dummy()void"
	txna ApplicationArgs 0
	match abi_route_startUpload abi_route_upload abi_route_finishUpload abi_route_startDelete abi_route_deleteData abi_route_dummy
	err

call_UpdateApplication:
	method "updateApplication()void"
	txna ApplicationArgs 0
	match abi_route_updateApplication
	err", - "clear": "I3ByYWdtYSB2ZXJzaW9uIDkKaW50IDE=" - }, - "contract": { - "name": "AlgoDID", - "desc": "", - "methods": [ - { - "name": "startUpload", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The pubkey of the DID" - }, - { - "name": "numBoxes", - "type": "uint64", - "desc": "The number of boxes that the data will take up" - }, - { - "name": "endBoxSize", - "type": "uint64", - "desc": "The size of the last box" - }, - { - "name": "mbrPayment", - "type": "pay", - "desc": "Payment from the uploader to cover the box MBR" - } - ], - "desc": "Allocate boxes to begin data upload process", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "upload", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The pubkey of the DID" - }, - { - "name": "boxIndex", - "type": "uint64", - "desc": "The index of the box to upload the given chunk of data to" - }, - { - "name": "offset", - "type": "uint64", - "desc": "The offset within the box to start writing the data" - }, - { - "name": "data", - "type": "byte[]", - "desc": "The data to write" - } - ], - "desc": "Upload data to a specific offset in a box", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "finishUpload", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The address of the DID" - } - ], - "desc": "Mark uploading as false", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "startDelete", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The address of the DID" - } - ], - "desc": "Starts the deletion process for the data associated with a DID", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "deleteData", - "args": [ - { - "name": "pubKey", - "type": "address", - "desc": "The address of the DID" - }, - { - "name": "boxIndex", - "type": "uint64", - "desc": "The index of the box to delete" - } - ], - "desc": "Deletes a box of data", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "updateApplication", - "args": [], - "desc": "Allow the contract to be updated by the creator", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "dummy", - "args": [], - "desc": "Dummy function to add extra box references for deleteData.Boxes are 32k, but a single app call can only inlcude enough references to read/write 8kat a time. Thus when a box is deleted, we need to add additional dummy calls with boxreferences to increase the total read/write budget to 32k.", - "returns": { - "type": "void", - "desc": "" - } - }, - { - "name": "createApplication", - "desc": "", - "returns": { - "type": "void", - "desc": "" - }, - "args": [] - } - ] - } -} - -/** - * Defines an onCompletionAction of 'no_op' - */ -export type OnCompleteNoOp = { onCompleteAction?: 'no_op' | OnApplicationComplete.NoOpOC } -/** - * Defines an onCompletionAction of 'opt_in' - */ -export type OnCompleteOptIn = { onCompleteAction: 'opt_in' | OnApplicationComplete.OptInOC } -/** - * Defines an onCompletionAction of 'close_out' - */ -export type OnCompleteCloseOut = { onCompleteAction: 'close_out' | OnApplicationComplete.CloseOutOC } -/** - * Defines an onCompletionAction of 'delete_application' - */ -export type OnCompleteDelApp = { onCompleteAction: 'delete_application' | OnApplicationComplete.DeleteApplicationOC } -/** - * Defines an onCompletionAction of 'update_application' - */ -export type OnCompleteUpdApp = { onCompleteAction: 'update_application' | OnApplicationComplete.UpdateApplicationOC } -/** - * A state record containing a single unsigned integer - */ -export type IntegerState = { - /** - * Gets the state value as a BigInt - */ - asBigInt(): bigint - /** - * Gets the state value as a number. - */ - asNumber(): number -} -/** - * A state record containing binary data - */ -export type BinaryState = { - /** - * Gets the state value as a Uint8Array - */ - asByteArray(): Uint8Array - /** - * Gets the state value as a string - */ - asString(): string -} - -/** - * Defines the types of available calls and state of the AlgoDid smart contract. - */ -export type AlgoDid = { - /** - * Maps method signatures / names to their argument and return types. - */ - methods: - & Record<'startUpload(address,uint64,uint64,pay)void' | 'startUpload', { - argsObj: { - /** - * The pubkey of the DID - */ - pubKey: string - /** - * The number of boxes that the data will take up - */ - numBoxes: bigint | number - /** - * The size of the last box - */ - endBoxSize: bigint | number - /** - * Payment from the uploader to cover the box MBR - */ - mbrPayment: TransactionToSign | Transaction | Promise - } - argsTuple: [pubKey: string, numBoxes: bigint | number, endBoxSize: bigint | number, mbrPayment: TransactionToSign | Transaction | Promise] - returns: void - }> - & Record<'upload(address,uint64,uint64,byte[])void' | 'upload', { - argsObj: { - /** - * The pubkey of the DID - */ - pubKey: string - /** - * The index of the box to upload the given chunk of data to - */ - boxIndex: bigint | number - /** - * The offset within the box to start writing the data - */ - offset: bigint | number - /** - * The data to write - */ - data: Uint8Array - } - argsTuple: [pubKey: string, boxIndex: bigint | number, offset: bigint | number, data: Uint8Array] - returns: void - }> - & Record<'finishUpload(address)void' | 'finishUpload', { - argsObj: { - /** - * The address of the DID - */ - pubKey: string - } - argsTuple: [pubKey: string] - returns: void - }> - & Record<'startDelete(address)void' | 'startDelete', { - argsObj: { - /** - * The address of the DID - */ - pubKey: string - } - argsTuple: [pubKey: string] - returns: void - }> - & Record<'deleteData(address,uint64)void' | 'deleteData', { - argsObj: { - /** - * The address of the DID - */ - pubKey: string - /** - * The index of the box to delete - */ - boxIndex: bigint | number - } - argsTuple: [pubKey: string, boxIndex: bigint | number] - returns: void - }> - & Record<'updateApplication()void' | 'updateApplication', { - argsObj: { - } - argsTuple: [] - returns: void - }> - & Record<'dummy()void' | 'dummy', { - argsObj: { - } - argsTuple: [] - returns: void - }> - & Record<'createApplication()void' | 'createApplication', { - argsObj: { - } - argsTuple: [] - returns: void - }> - /** - * Defines the shape of the global and local state of the application. - */ - state: { - global: { - 'currentIndex'?: IntegerState - } - } -} -/** - * Defines the possible abi call signatures - */ -export type AlgoDidSig = keyof AlgoDid['methods'] -/** - * Defines an object containing all relevant parameters for a single call to the contract. Where TSignature is undefined, a bare call is made - */ -export type TypedCallParams = { - method: TSignature - methodArgs: TSignature extends undefined ? undefined : Array -} & AppClientCallCoreParams & CoreAppCallArgs -/** - * Defines the arguments required for a bare call - */ -export type BareCallArgs = Omit -/** - * Maps a method signature from the AlgoDid smart contract to the method's arguments in either tuple of struct form - */ -export type MethodArgs = AlgoDid['methods'][TSignature]['argsObj' | 'argsTuple'] -/** - * Maps a method signature from the AlgoDid smart contract to the method's return type - */ -export type MethodReturn = AlgoDid['methods'][TSignature]['returns'] - -/** - * A factory for available 'create' calls - */ -export type AlgoDidCreateCalls = (typeof AlgoDidCallFactory)['create'] -/** - * Defines supported create methods for this smart contract - */ -export type AlgoDidCreateCallParams = - | (TypedCallParams<'createApplication()void'> & (OnCompleteNoOp)) -/** - * A factory for available 'update' calls - */ -export type AlgoDidUpdateCalls = (typeof AlgoDidCallFactory)['update'] -/** - * Defines supported update methods for this smart contract - */ -export type AlgoDidUpdateCallParams = - | TypedCallParams<'updateApplication()void'> -/** - * Defines arguments required for the deploy method. - */ -export type AlgoDidDeployArgs = { - deployTimeParams?: TealTemplateParams - /** - * A delegate which takes a create call factory and returns the create call params for this smart contract - */ - createCall?: (callFactory: AlgoDidCreateCalls) => AlgoDidCreateCallParams - /** - * A delegate which takes a update call factory and returns the update call params for this smart contract - */ - updateCall?: (callFactory: AlgoDidUpdateCalls) => AlgoDidUpdateCallParams -} - - -/** - * Exposes methods for constructing all available smart contract calls - */ -export abstract class AlgoDidCallFactory { - /** - * Gets available create call factories - */ - static get create() { - return { - /** - * Constructs a create call for the AlgoDID smart contract using the createApplication()void ABI method - * - * @param args Any args for the contract call - * @param params Any additional parameters for the call - * @returns A TypedCallParams object for the call - */ - createApplication(args: MethodArgs<'createApplication()void'>, params: AppClientCallCoreParams & CoreAppCallArgs & AppClientCompilationParams & (OnCompleteNoOp) = {}) { - return { - method: 'createApplication()void' as const, - methodArgs: Array.isArray(args) ? args : [], - ...params, - } - }, - } - } - - /** - * Gets available update call factories - */ - static get update() { - return { - /** - * Constructs an update call for the AlgoDID smart contract using the updateApplication()void ABI method - * - * @param args Any args for the contract call - * @param params Any additional parameters for the call - * @returns A TypedCallParams object for the call - */ - updateApplication(args: MethodArgs<'updateApplication()void'>, params: AppClientCallCoreParams & CoreAppCallArgs & AppClientCompilationParams = {}) { - return { - method: 'updateApplication()void' as const, - methodArgs: Array.isArray(args) ? args : [], - ...params, - } - }, - } - } - - /** - * Constructs a no op call for the startUpload(address,uint64,uint64,pay)void ABI method - * - * Allocate boxes to begin data upload process - * - * @param args Any args for the contract call - * @param params Any additional parameters for the call - * @returns A TypedCallParams object for the call - */ - static startUpload(args: MethodArgs<'startUpload(address,uint64,uint64,pay)void'>, params: AppClientCallCoreParams & CoreAppCallArgs) { - return { - method: 'startUpload(address,uint64,uint64,pay)void' as const, - methodArgs: Array.isArray(args) ? args : [args.pubKey, args.numBoxes, args.endBoxSize, args.mbrPayment], - ...params, - } - } - /** - * Constructs a no op call for the upload(address,uint64,uint64,byte[])void ABI method - * - * Upload data to a specific offset in a box - * - * @param args Any args for the contract call - * @param params Any additional parameters for the call - * @returns A TypedCallParams object for the call - */ - static upload(args: MethodArgs<'upload(address,uint64,uint64,byte[])void'>, params: AppClientCallCoreParams & CoreAppCallArgs) { - return { - method: 'upload(address,uint64,uint64,byte[])void' as const, - methodArgs: Array.isArray(args) ? args : [args.pubKey, args.boxIndex, args.offset, args.data], - ...params, - } - } - /** - * Constructs a no op call for the finishUpload(address)void ABI method - * - * Mark uploading as false - * - * @param args Any args for the contract call - * @param params Any additional parameters for the call - * @returns A TypedCallParams object for the call - */ - static finishUpload(args: MethodArgs<'finishUpload(address)void'>, params: AppClientCallCoreParams & CoreAppCallArgs) { - return { - method: 'finishUpload(address)void' as const, - methodArgs: Array.isArray(args) ? args : [args.pubKey], - ...params, - } - } - /** - * Constructs a no op call for the startDelete(address)void ABI method - * - * Starts the deletion process for the data associated with a DID - * - * @param args Any args for the contract call - * @param params Any additional parameters for the call - * @returns A TypedCallParams object for the call - */ - static startDelete(args: MethodArgs<'startDelete(address)void'>, params: AppClientCallCoreParams & CoreAppCallArgs) { - return { - method: 'startDelete(address)void' as const, - methodArgs: Array.isArray(args) ? args : [args.pubKey], - ...params, - } - } - /** - * Constructs a no op call for the deleteData(address,uint64)void ABI method - * - * Deletes a box of data - * - * @param args Any args for the contract call - * @param params Any additional parameters for the call - * @returns A TypedCallParams object for the call - */ - static deleteData(args: MethodArgs<'deleteData(address,uint64)void'>, params: AppClientCallCoreParams & CoreAppCallArgs) { - return { - method: 'deleteData(address,uint64)void' as const, - methodArgs: Array.isArray(args) ? args : [args.pubKey, args.boxIndex], - ...params, - } - } - /** - * Constructs a no op call for the dummy()void ABI method - * - * Dummy function to add extra box references for deleteData.Boxes are 32k, but a single app call can only inlcude enough references to read/write 8kat a time. Thus when a box is deleted, we need to add additional dummy calls with boxreferences to increase the total read/write budget to 32k. - * - * @param args Any args for the contract call - * @param params Any additional parameters for the call - * @returns A TypedCallParams object for the call - */ - static dummy(args: MethodArgs<'dummy()void'>, params: AppClientCallCoreParams & CoreAppCallArgs) { - return { - method: 'dummy()void' as const, - methodArgs: Array.isArray(args) ? args : [], - ...params, - } - } -} - -/** - * A client to make calls to the AlgoDID smart contract - */ -export class AlgoDidClient { - /** - * The underlying `ApplicationClient` for when you want to have more flexibility - */ - public readonly appClient: ApplicationClient - - private readonly sender: SendTransactionFrom | undefined - - /** - * Creates a new instance of `AlgoDidClient` - * - * @param appDetails appDetails The details to identify the app to deploy - * @param algod An algod client instance - */ - constructor(appDetails: AppDetails, private algod: Algodv2) { - this.sender = appDetails.sender - this.appClient = algokit.getAppClient({ - ...appDetails, - app: APP_SPEC - }, algod) - } - - /** - * Checks for decode errors on the AppCallTransactionResult and maps the return value to the specified generic type - * - * @param result The AppCallTransactionResult to be mapped - * @param returnValueFormatter An optional delegate to format the return value if required - * @returns The smart contract response with an updated return value - */ - protected mapReturnValue(result: AppCallTransactionResult, returnValueFormatter?: (value: any) => TReturn): AppCallTransactionResultOfType { - if(result.return?.decodeError) { - throw result.return.decodeError - } - const returnValue = result.return?.returnValue !== undefined && returnValueFormatter !== undefined - ? returnValueFormatter(result.return.returnValue) - : result.return?.returnValue as TReturn | undefined - return { ...result, return: returnValue } - } - - /** - * Calls the ABI method with the matching signature using an onCompletion code of NO_OP - * - * @param typedCallParams An object containing the method signature, args, and any other relevant parameters - * @param returnValueFormatter An optional delegate which when provided will be used to map non-undefined return values to the target type - * @returns The result of the smart contract call - */ - public async call(typedCallParams: TypedCallParams, returnValueFormatter?: (value: any) => MethodReturn) { - return this.mapReturnValue>(await this.appClient.call(typedCallParams), returnValueFormatter) - } - - /** - * Idempotently deploys the AlgoDID smart contract. - * - * @param params The arguments for the contract calls and any additional parameters for the call - * @returns The deployment result - */ - public deploy(params: AlgoDidDeployArgs & AppClientDeployCoreParams = {}): ReturnType { - const createArgs = params.createCall?.(AlgoDidCallFactory.create) - const updateArgs = params.updateCall?.(AlgoDidCallFactory.update) - return this.appClient.deploy({ - ...params, - updateArgs, - createArgs, - createOnCompleteAction: createArgs?.onCompleteAction, - }) - } - - /** - * Gets available create methods - */ - public get create() { - const $this = this - return { - /** - * Creates a new instance of the AlgoDID smart contract using the createApplication()void ABI method. - * - * @param args The arguments for the smart contract call - * @param params Any additional parameters for the call - * @returns The create result - */ - async createApplication(args: MethodArgs<'createApplication()void'>, params: AppClientCallCoreParams & AppClientCompilationParams & (OnCompleteNoOp) = {}): Promise>> { - return $this.mapReturnValue(await $this.appClient.create(AlgoDidCallFactory.create.createApplication(args, params))) - }, - } - } - - /** - * Gets available update methods - */ - public get update() { - const $this = this - return { - /** - * Updates an existing instance of the AlgoDID smart contract using the updateApplication()void ABI method. - * - * @param args The arguments for the smart contract call - * @param params Any additional parameters for the call - * @returns The update result - */ - async updateApplication(args: MethodArgs<'updateApplication()void'>, params: AppClientCallCoreParams & AppClientCompilationParams = {}): Promise>> { - return $this.mapReturnValue(await $this.appClient.update(AlgoDidCallFactory.update.updateApplication(args, params))) - }, - } - } - - /** - * Makes a clear_state call to an existing instance of the AlgoDID smart contract. - * - * @param args The arguments for the bare call - * @returns The clear_state result - */ - public clearState(args: BareCallArgs & AppClientCallCoreParams & CoreAppCallArgs = {}) { - return this.appClient.clearState(args) - } - - /** - * Calls the startUpload(address,uint64,uint64,pay)void ABI method. - * - * Allocate boxes to begin data upload process - * - * @param args The arguments for the contract call - * @param params Any additional parameters for the call - * @returns The result of the call - */ - public startUpload(args: MethodArgs<'startUpload(address,uint64,uint64,pay)void'>, params: AppClientCallCoreParams & CoreAppCallArgs = {}) { - return this.call(AlgoDidCallFactory.startUpload(args, params)) - } - - /** - * Calls the upload(address,uint64,uint64,byte[])void ABI method. - * - * Upload data to a specific offset in a box - * - * @param args The arguments for the contract call - * @param params Any additional parameters for the call - * @returns The result of the call - */ - public upload(args: MethodArgs<'upload(address,uint64,uint64,byte[])void'>, params: AppClientCallCoreParams & CoreAppCallArgs = {}) { - return this.call(AlgoDidCallFactory.upload(args, params)) - } - - /** - * Calls the finishUpload(address)void ABI method. - * - * Mark uploading as false - * - * @param args The arguments for the contract call - * @param params Any additional parameters for the call - * @returns The result of the call - */ - public finishUpload(args: MethodArgs<'finishUpload(address)void'>, params: AppClientCallCoreParams & CoreAppCallArgs = {}) { - return this.call(AlgoDidCallFactory.finishUpload(args, params)) - } - - /** - * Calls the startDelete(address)void ABI method. - * - * Starts the deletion process for the data associated with a DID - * - * @param args The arguments for the contract call - * @param params Any additional parameters for the call - * @returns The result of the call - */ - public startDelete(args: MethodArgs<'startDelete(address)void'>, params: AppClientCallCoreParams & CoreAppCallArgs = {}) { - return this.call(AlgoDidCallFactory.startDelete(args, params)) - } - - /** - * Calls the deleteData(address,uint64)void ABI method. - * - * Deletes a box of data - * - * @param args The arguments for the contract call - * @param params Any additional parameters for the call - * @returns The result of the call - */ - public deleteData(args: MethodArgs<'deleteData(address,uint64)void'>, params: AppClientCallCoreParams & CoreAppCallArgs = {}) { - return this.call(AlgoDidCallFactory.deleteData(args, params)) - } - - /** - * Calls the dummy()void ABI method. - * - * Dummy function to add extra box references for deleteData.Boxes are 32k, but a single app call can only inlcude enough references to read/write 8kat a time. Thus when a box is deleted, we need to add additional dummy calls with boxreferences to increase the total read/write budget to 32k. - * - * @param args The arguments for the contract call - * @param params Any additional parameters for the call - * @returns The result of the call - */ - public dummy(args: MethodArgs<'dummy()void'>, params: AppClientCallCoreParams & CoreAppCallArgs = {}) { - return this.call(AlgoDidCallFactory.dummy(args, params)) - } - - /** - * Extracts a binary state value out of an AppState dictionary - * - * @param state The state dictionary containing the state value - * @param key The key of the state value - * @returns A BinaryState instance containing the state value, or undefined if the key was not found - */ - private static getBinaryState(state: AppState, key: string): BinaryState | undefined { - const value = state[key] - if (!value) return undefined - if (!('valueRaw' in value)) - throw new Error(`Failed to parse state value for ${key}; received an int when expected a byte array`) - return { - asString(): string { - return value.value - }, - asByteArray(): Uint8Array { - return value.valueRaw - } - } - } - - /** - * Extracts a integer state value out of an AppState dictionary - * - * @param state The state dictionary containing the state value - * @param key The key of the state value - * @returns An IntegerState instance containing the state value, or undefined if the key was not found - */ - private static getIntegerState(state: AppState, key: string): IntegerState | undefined { - const value = state[key] - if (!value) return undefined - if ('valueRaw' in value) - throw new Error(`Failed to parse state value for ${key}; received a byte array when expected a number`) - return { - asBigInt() { - return typeof value.value === 'bigint' ? value.value : BigInt(value.value) - }, - asNumber(): number { - return typeof value.value === 'bigint' ? Number(value.value) : value.value - }, - } - } - - /** - * Returns the smart contract's global state wrapped in a strongly typed accessor with options to format the stored value - */ - public async getGlobalState(): Promise { - const state = await this.appClient.getGlobalState() - return { - get currentIndex() { - return AlgoDidClient.getIntegerState(state, 'currentIndex') - }, - } - } - - public compose(): AlgoDidComposer { - const client = this - const atc = new AtomicTransactionComposer() - let promiseChain:Promise = Promise.resolve() - const resultMappers: Array any)> = [] - return { - startUpload(args: MethodArgs<'startUpload(address,uint64,uint64,pay)void'>, params?: AppClientCallCoreParams & CoreAppCallArgs) { - promiseChain = promiseChain.then(() => client.startUpload(args, {...params, sendParams: {...params?.sendParams, skipSending: true, atc}})) - resultMappers.push(undefined) - return this - }, - upload(args: MethodArgs<'upload(address,uint64,uint64,byte[])void'>, params?: AppClientCallCoreParams & CoreAppCallArgs) { - promiseChain = promiseChain.then(() => client.upload(args, {...params, sendParams: {...params?.sendParams, skipSending: true, atc}})) - resultMappers.push(undefined) - return this - }, - finishUpload(args: MethodArgs<'finishUpload(address)void'>, params?: AppClientCallCoreParams & CoreAppCallArgs) { - promiseChain = promiseChain.then(() => client.finishUpload(args, {...params, sendParams: {...params?.sendParams, skipSending: true, atc}})) - resultMappers.push(undefined) - return this - }, - startDelete(args: MethodArgs<'startDelete(address)void'>, params?: AppClientCallCoreParams & CoreAppCallArgs) { - promiseChain = promiseChain.then(() => client.startDelete(args, {...params, sendParams: {...params?.sendParams, skipSending: true, atc}})) - resultMappers.push(undefined) - return this - }, - deleteData(args: MethodArgs<'deleteData(address,uint64)void'>, params?: AppClientCallCoreParams & CoreAppCallArgs) { - promiseChain = promiseChain.then(() => client.deleteData(args, {...params, sendParams: {...params?.sendParams, skipSending: true, atc}})) - resultMappers.push(undefined) - return this - }, - dummy(args: MethodArgs<'dummy()void'>, params?: AppClientCallCoreParams & CoreAppCallArgs) { - promiseChain = promiseChain.then(() => client.dummy(args, {...params, sendParams: {...params?.sendParams, skipSending: true, atc}})) - resultMappers.push(undefined) - return this - }, - get update() { - const $this = this - return { - updateApplication(args: MethodArgs<'updateApplication()void'>, params?: AppClientCallCoreParams & AppClientCompilationParams) { - promiseChain = promiseChain.then(() => client.update.updateApplication(args, {...params, sendParams: {...params?.sendParams, skipSending: true, atc}})) - resultMappers.push(undefined) - return $this - }, - } - }, - clearState(args?: BareCallArgs & AppClientCallCoreParams & CoreAppCallArgs) { - promiseChain = promiseChain.then(() => client.clearState({...args, sendParams: {...args?.sendParams, skipSending: true, atc}})) - resultMappers.push(undefined) - return this - }, - addTransaction(txn: TransactionWithSigner | TransactionToSign | Transaction | Promise, defaultSender?: SendTransactionFrom) { - promiseChain = promiseChain.then(async () => atc.addTransaction(await algokit.getTransactionWithSigner(txn, defaultSender ?? client.sender))) - return this - }, - async atc() { - await promiseChain - return atc - }, - async execute() { - await promiseChain - const result = await algokit.sendAtomicTransactionComposer({ atc, sendParams: {} }, client.algod) - return { - ...result, - returns: result.returns?.map((val, i) => resultMappers[i] !== undefined ? resultMappers[i]!(val.returnValue) : val.returnValue) - } - } - } as unknown as AlgoDidComposer - } -} -export type AlgoDidComposer = { - /** - * Calls the startUpload(address,uint64,uint64,pay)void ABI method. - * - * Allocate boxes to begin data upload process - * - * @param args The arguments for the contract call - * @param params Any additional parameters for the call - * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions - */ - startUpload(args: MethodArgs<'startUpload(address,uint64,uint64,pay)void'>, params?: AppClientCallCoreParams & CoreAppCallArgs): AlgoDidComposer<[...TReturns, MethodReturn<'startUpload(address,uint64,uint64,pay)void'>]> - - /** - * Calls the upload(address,uint64,uint64,byte[])void ABI method. - * - * Upload data to a specific offset in a box - * - * @param args The arguments for the contract call - * @param params Any additional parameters for the call - * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions - */ - upload(args: MethodArgs<'upload(address,uint64,uint64,byte[])void'>, params?: AppClientCallCoreParams & CoreAppCallArgs): AlgoDidComposer<[...TReturns, MethodReturn<'upload(address,uint64,uint64,byte[])void'>]> - - /** - * Calls the finishUpload(address)void ABI method. - * - * Mark uploading as false - * - * @param args The arguments for the contract call - * @param params Any additional parameters for the call - * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions - */ - finishUpload(args: MethodArgs<'finishUpload(address)void'>, params?: AppClientCallCoreParams & CoreAppCallArgs): AlgoDidComposer<[...TReturns, MethodReturn<'finishUpload(address)void'>]> - - /** - * Calls the startDelete(address)void ABI method. - * - * Starts the deletion process for the data associated with a DID - * - * @param args The arguments for the contract call - * @param params Any additional parameters for the call - * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions - */ - startDelete(args: MethodArgs<'startDelete(address)void'>, params?: AppClientCallCoreParams & CoreAppCallArgs): AlgoDidComposer<[...TReturns, MethodReturn<'startDelete(address)void'>]> - - /** - * Calls the deleteData(address,uint64)void ABI method. - * - * Deletes a box of data - * - * @param args The arguments for the contract call - * @param params Any additional parameters for the call - * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions - */ - deleteData(args: MethodArgs<'deleteData(address,uint64)void'>, params?: AppClientCallCoreParams & CoreAppCallArgs): AlgoDidComposer<[...TReturns, MethodReturn<'deleteData(address,uint64)void'>]> - - /** - * Calls the dummy()void ABI method. - * - * Dummy function to add extra box references for deleteData.Boxes are 32k, but a single app call can only inlcude enough references to read/write 8kat a time. Thus when a box is deleted, we need to add additional dummy calls with boxreferences to increase the total read/write budget to 32k. - * - * @param args The arguments for the contract call - * @param params Any additional parameters for the call - * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions - */ - dummy(args: MethodArgs<'dummy()void'>, params?: AppClientCallCoreParams & CoreAppCallArgs): AlgoDidComposer<[...TReturns, MethodReturn<'dummy()void'>]> - - /** - * Gets available update methods - */ - readonly update: { - /** - * Updates an existing instance of the AlgoDID smart contract using the updateApplication()void ABI method. - * - * @param args The arguments for the smart contract call - * @param params Any additional parameters for the call - * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions - */ - updateApplication(args: MethodArgs<'updateApplication()void'>, params?: AppClientCallCoreParams & AppClientCompilationParams): AlgoDidComposer<[...TReturns, MethodReturn<'updateApplication()void'>]> - } - - /** - * Makes a clear_state call to an existing instance of the AlgoDID smart contract. - * - * @param args The arguments for the bare call - * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions - */ - clearState(args?: BareCallArgs & AppClientCallCoreParams & CoreAppCallArgs): AlgoDidComposer<[...TReturns, undefined]> - - /** - * Adds a transaction to the composer - * - * @param txn One of: A TransactionWithSigner object (returned as is), a TransactionToSign object (signer is obtained from the signer property), a Transaction object (signer is extracted from the defaultSender parameter), an async SendTransactionResult returned by one of algokit utils helpers (signer is obtained from the defaultSender parameter) - * @param defaultSender The default sender to be used to obtain a signer where the object provided to the transaction parameter does not include a signer. - */ - addTransaction(txn: TransactionWithSigner | TransactionToSign | Transaction | Promise, defaultSender?: SendTransactionFrom): AlgoDidComposer - /** - * Returns the underlying AtomicTransactionComposer instance - */ - atc(): Promise - /** - * Executes the transaction group and returns an array of results - */ - execute(): Promise> -} -export type AlgoDidComposerResults = { - returns: TReturns - groupId: string - txIds: string[] - transactions: Transaction[] -} diff --git a/reference_contract/contracts/algo-did.algo.ts b/reference_contract/contracts/did-algo-storage.algo.ts similarity index 99% rename from reference_contract/contracts/algo-did.algo.ts rename to reference_contract/contracts/did-algo-storage.algo.ts index 74901f9..0ddcd18 100644 --- a/reference_contract/contracts/algo-did.algo.ts +++ b/reference_contract/contracts/did-algo-storage.algo.ts @@ -35,7 +35,7 @@ const COST_PER_BYTE = 400; const COST_PER_BOX = 2500; const MAX_BOX_SIZE = 32768; -export class AlgoDID extends Contract { +export class DIDAlgoStorage extends Contract { /** The boxes that contain the data, indexed by uint64 */ dataBoxes = BoxMap(); diff --git a/reference_contract/package-lock.json b/reference_contract/package-lock.json index 34eb441..e0ea321 100644 --- a/reference_contract/package-lock.json +++ b/reference_contract/package-lock.json @@ -1,11 +1,11 @@ { - "name": "algo-did", + "name": "did-algo-storage", "version": "0.0.0", "lockfileVersion": 2, "requires": true, "packages": { "": { - "name": "algo-did", + "name": "did-algo-storage", "version": "0.0.0", "license": "MIT", "dependencies": { diff --git a/reference_contract/package.json b/reference_contract/package.json index 6052e58..c020c34 100644 --- a/reference_contract/package.json +++ b/reference_contract/package.json @@ -1,11 +1,10 @@ { - "name": "algo-did", + "name": "did-algo-storage", "version": "0.0.0", "license": "MIT", "scripts": { - "compile-contract": "tealscript contracts/algo-did.algo.ts contracts/artifacts", - "generate-client": "algokitgen generate -a contracts/artifacts/AlgoDID.json -o contracts/clients/AlgoDIDClient.ts", - "build": "npm run compile-contract && cp contracts/artifacts/AlgoDID* ../client/internal/contracts", + "compile-contract": "tealscript contracts/did-algo-storage.algo.ts contracts/artifacts", + "build": "npm run compile-contract && cp contracts/artifacts/* ../client/internal/contracts", "test": "npm run build && jest", "lint": "eslint . --ext .ts", "fix": "eslint . --ext .ts --fix" diff --git a/reference_contract/src/index.ts b/reference_contract/src/index.ts index af13588..7787045 100644 --- a/reference_contract/src/index.ts +++ b/reference_contract/src/index.ts @@ -5,7 +5,7 @@ import { ApplicationClient } from '@algorandfoundation/algokit-utils/types/app-c import { AppCallTransactionResult } from '@algorandfoundation/algokit-utils/types/app'; import { expect } from '@jest/globals'; import { SuggestedParamsWithMinFee } from 'algosdk/dist/types/types/transactions/base'; -import appSpec from '../contracts/artifacts/AlgoDID.json'; +import appSpec from '../contracts/artifacts/DIDAlgoStorage.arc32.json'; const COST_PER_BYTE = 400; const COST_PER_BOX = 2500; From 53191016e2ac37c195c626ba5e3c860bb6413b5f Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Wed, 19 Jun 2024 13:55:38 -0400 Subject: [PATCH 8/9] update storage contract name in go code --- client/cli/cmd/deploy.go | 2 +- client/cli/cmd/utils.go | 2 +- client/internal/contracts.go | 4 ++-- client/internal/driver.go | 2 +- client/internal/main.go | 26 +++++++++++++------------- client/internal/utils.go | 8 ++++---- client/ui/api.go | 2 +- client/ui/api_test.go | 2 +- client/ui/provider.go | 2 +- 9 files changed, 25 insertions(+), 25 deletions(-) diff --git a/client/cli/cmd/deploy.go b/client/cli/cmd/deploy.go index 5bc9707..f59d173 100644 --- a/client/cli/cmd/deploy.go +++ b/client/cli/cmd/deploy.go @@ -13,7 +13,7 @@ import ( var deployContractCmd = &cobra.Command{ Use: "deploy", Aliases: []string{"deploy-contract"}, - Short: "Deploy the AlgoDID storage smart contract", + Short: "Deploy the DIDAlgoStorage smart contract", Example: "algoid deploy [wallet-name] [network]", RunE: runDeployContractCmd, } diff --git a/client/cli/cmd/utils.go b/client/cli/cmd/utils.go index 3be8e69..18e4319 100644 --- a/client/cli/cmd/utils.go +++ b/client/cli/cmd/utils.go @@ -36,7 +36,7 @@ func getStorageAppID(network string) (uint, error) { } // Get network client instance. -func getAlgoClient() (*internal.AlgoDIDClient, error) { +func getAlgoClient() (*internal.DIDAlgoStorageClient, error) { conf := new(internal.ClientSettings) if err := viper.UnmarshalKey("network", &conf); err != nil { return nil, err diff --git a/client/internal/contracts.go b/client/internal/contracts.go index 3440f49..3a1db8d 100644 --- a/client/internal/contracts.go +++ b/client/internal/contracts.go @@ -13,7 +13,7 @@ import ( // https://developer.algorand.org/docs/get-details/encoding/ // StorageContracts contains the pre-compiled smart contracts to -// support AlgoDID's on-chain storage. +// support DIDAlgoStorage's on-chain storage. var StorageContracts fs.FS //go:embed contracts @@ -50,7 +50,7 @@ func init() { _ = clearFile.Close() } -// LoadContract loads the AlgoDID smart contract ABI from JSON file. +// LoadContract loads the DIDAlgoStorage smart contract ABI from JSON file. func LoadContract() *abi.Contract { abiFile, _ := StorageContracts.Open("DIDAlgoStorage.arc4.json") abiContents, _ := io.ReadAll(abiFile) diff --git a/client/internal/driver.go b/client/internal/driver.go index 6b1ffbf..e7c53ac 100644 --- a/client/internal/driver.go +++ b/client/internal/driver.go @@ -9,7 +9,7 @@ import ( // Read a DID document from the Algorand network. The method complies // with the `resolver.Provider` interface. -func (c *AlgoDIDClient) Read(id string) (*did.Document, *did.DocumentMetadata, error) { +func (c *DIDAlgoStorageClient) Read(id string) (*did.Document, *did.DocumentMetadata, error) { if _, err := did.Parse(id); err != nil { return nil, nil, errors.New(resolver.ErrInvalidDID) } diff --git a/client/internal/main.go b/client/internal/main.go index 94b7d84..0e1000f 100644 --- a/client/internal/main.go +++ b/client/internal/main.go @@ -21,13 +21,13 @@ import ( ) // ClientSettings defines the configuration options available when -// interacting with an AlgoDID network agent. +// interacting with an DIDAlgoStorage network agent. type ClientSettings struct { Profiles []*NetworkProfile `json:"profiles" yaml:"profiles" mapstructure:"profiles"` } // NetworkProfile defines the configuration options to connect to a -// specific AlgoDID network agent. +// specific DIDAlgoStorage network agent. type NetworkProfile struct { // Profile name. Name string `json:"name" yaml:"name" mapstructure:"name"` @@ -38,7 +38,7 @@ type NetworkProfile struct { // Algod node access token. NodeToken string `json:"node_token,omitempty" yaml:"node_token,omitempty" mapstructure:"node_token"` - // Application ID for the AlgoDID storage smart contract. + // Application ID for the DIDAlgoStorage smart contract. AppID uint `json:"app_id" yaml:"app_id" mapstructure:"app_id"` // Storage contract provider server, if any. @@ -51,21 +51,21 @@ type NetworkClient struct { algod *algod.Client } -// AlgoDIDClient provides a simplified interface to interact with the +// DIDAlgoStorageClient provides a simplified interface to interact with the // Algorand network. -type AlgoDIDClient struct { +type DIDAlgoStorageClient struct { log xlog.Logger httpC *http.Client Networks map[string]*NetworkClient } // NewAlgoClient creates a new instance of the AlgoClient. -func NewAlgoClient(profiles []*NetworkProfile, log xlog.Logger) (*AlgoDIDClient, error) { +func NewAlgoClient(profiles []*NetworkProfile, log xlog.Logger) (*DIDAlgoStorageClient, error) { if len(profiles) == 0 { return nil, fmt.Errorf("no network profile provided") } - client := &AlgoDIDClient{ + client := &DIDAlgoStorageClient{ log: log, httpC: &http.Client{}, Networks: make(map[string]*NetworkClient), @@ -85,7 +85,7 @@ func NewAlgoClient(profiles []*NetworkProfile, log xlog.Logger) (*AlgoDIDClient, return client, nil } -// StorageAppID returns the application ID for the AlgoDID storage. +// StorageAppID returns the application ID for the DIDAlgoStorage. func (c *NetworkClient) StorageAppID() uint { return c.profile.AppID } @@ -110,7 +110,7 @@ func (c *NetworkClient) Ready() bool { return c.algod.HealthCheck().Do(context.TODO()) == nil } -// DeployContract creates a new instance of the AlgoDID storage smart contract +// DeployContract creates a new instance of the DIDAlgoStorage smart contract // on the network. func (c *NetworkClient) DeployContract(sender *crypto.Account) (uint64, error) { contract := LoadContract() @@ -120,7 +120,7 @@ func (c *NetworkClient) DeployContract(sender *crypto.Account) (uint64, error) { // PublishDID sends a new DID document to the network // fot on-chain storage. -func (c *AlgoDIDClient) PublishDID(id *did.Identifier, sender *crypto.Account) error { +func (c *DIDAlgoStorageClient) PublishDID(id *did.Identifier, sender *crypto.Account) error { c.log.WithFields(map[string]interface{}{ "did": id.String(), }).Info("publishing DID document") @@ -140,7 +140,7 @@ func (c *AlgoDIDClient) PublishDID(id *did.Identifier, sender *crypto.Account) e } // DeleteDID removes a DID document from the network. -func (c *AlgoDIDClient) DeleteDID(id *did.Identifier, sender *crypto.Account) error { +func (c *DIDAlgoStorageClient) DeleteDID(id *did.Identifier, sender *crypto.Account) error { c.log.WithFields(map[string]interface{}{ "did": id.String(), }).Info("deleting DID document") @@ -159,7 +159,7 @@ func (c *AlgoDIDClient) DeleteDID(id *did.Identifier, sender *crypto.Account) er } // Resolve retrieves a DID document from the network. -func (c *AlgoDIDClient) Resolve(id string) (*did.Document, error) { +func (c *DIDAlgoStorageClient) Resolve(id string) (*did.Document, error) { c.log.WithField("did", id).Info("retrieving DID document") // Parse the DID @@ -188,7 +188,7 @@ func (c *AlgoDIDClient) Resolve(id string) (*did.Document, error) { return doc, nil } -func (c *AlgoDIDClient) submitToProvider(network string, pub []byte, appID uint64, method string, doc []byte) error { +func (c *DIDAlgoStorageClient) submitToProvider(network string, pub []byte, appID uint64, method string, doc []byte) error { networkClient := c.Networks[network] c.log.Warning("using provider: ", networkClient.profile.StoreProvider) diff --git a/client/internal/utils.go b/client/internal/utils.go index 90138ed..90a5be3 100644 --- a/client/internal/utils.go +++ b/client/internal/utils.go @@ -28,7 +28,7 @@ const ( betanetGenesisHash = "mFgazF+2uRS1tMiL9dsj01hJGySEmPN28B/TjjvpVW0=" ) -// CreateApp is used to deploy the AlgoDID storage smart contract to the +// CreateApp is used to deploy the DIDAlgoStorage smart contract to the // Algorand network. func CreateApp( algodClient *algod.Client, @@ -121,7 +121,7 @@ func CreateApp( return confirmedTxn.ApplicationIndex, nil } -// publishDID is used to upload a new DID document to the AlgoDID +// publishDID is used to upload a new DID document to the DIDAlgoStorage // storage smart contract. func publishDID( algodClient *algod.Client, @@ -309,7 +309,7 @@ func checkNetwork(network string, algodClient *algod.Client) error { return nil } -// ResolveDID is used to read the DID document from the AlgoDID storage smart +// ResolveDID is used to read the DID document from the DIDAlgoStorage smart // contract. func ResolveDID(appID uint64, pubKey []byte, algodClient *algod.Client, network string) ([]byte, error) { err := checkNetwork(network, algodClient) @@ -343,7 +343,7 @@ func ResolveDID(appID uint64, pubKey []byte, algodClient *algod.Client, network return data, nil } -// DeleteDID is used to delete the DID document from the AlgoDID +// DeleteDID is used to delete the DID document from the DIDAlgoStorage // storage smart contract. func deleteDID( appID uint64, diff --git a/client/ui/api.go b/client/ui/api.go index b0c3d8e..9c2522d 100644 --- a/client/ui/api.go +++ b/client/ui/api.go @@ -22,7 +22,7 @@ type LocalAPI struct { } // LocalAPIServer creates a new instance of the local API server. -func LocalAPIServer(st *store.LocalStore, client *internal.AlgoDIDClient, log xlog.Logger) (*LocalAPI, error) { +func LocalAPIServer(st *store.LocalStore, client *internal.DIDAlgoStorageClient, log xlog.Logger) (*LocalAPI, error) { // provider instances p := &Provider{ st: st, diff --git a/client/ui/api_test.go b/client/ui/api_test.go index f9b64fa..041ca2f 100644 --- a/client/ui/api_test.go +++ b/client/ui/api_test.go @@ -132,7 +132,7 @@ func TestMain(m *testing.M) { // // Algod node access token. // NodeToken string `json:"node_token,omitempty" yaml:"node_token,omitempty" mapstructure:"node_token"` - // // Application ID for the AlgoDID storage smart contract. + // // Application ID for the DIDAlgoStorage smart contract. // AppID uint `json:"app_id" yaml:"app_id" mapstructure:"app_id"` // // Storage contract provider server, if any. diff --git a/client/ui/provider.go b/client/ui/provider.go index 4eb4501..b885cf3 100644 --- a/client/ui/provider.go +++ b/client/ui/provider.go @@ -20,7 +20,7 @@ import ( type Provider struct { st *store.LocalStore log xlog.Logger - client *internal.AlgoDIDClient + client *internal.DIDAlgoStorageClient } // LocalEntry represents a DID instance stored in the local From dc084ab4f9efed7cf57264bb197265ef7837ea19 Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Wed, 19 Jun 2024 13:58:34 -0400 Subject: [PATCH 9/9] fix lint error --- client/internal/main.go | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/client/internal/main.go b/client/internal/main.go index 0e1000f..65d7224 100644 --- a/client/internal/main.go +++ b/client/internal/main.go @@ -188,7 +188,13 @@ func (c *DIDAlgoStorageClient) Resolve(id string) (*did.Document, error) { return doc, nil } -func (c *DIDAlgoStorageClient) submitToProvider(network string, pub []byte, appID uint64, method string, doc []byte) error { +func (c *DIDAlgoStorageClient) submitToProvider( + network string, + pub []byte, + appID uint64, + method string, + doc []byte, +) error { networkClient := c.Networks[network] c.log.Warning("using provider: ", networkClient.profile.StoreProvider)